r'''
# CDK Monitoring Constructs

[![NPM version](https://badge.fury.io/js/cdk-monitoring-constructs.svg)](https://badge.fury.io/js/cdk-monitoring-constructs)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdkmonitoringconstructs/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdkmonitoringconstructs)
[![PyPI version](https://badge.fury.io/py/cdk-monitoring-constructs.svg)](https://badge.fury.io/py/cdk-monitoring-constructs)
[![NuGet version](https://badge.fury.io/nu/Cdklabs.CdkMonitoringConstructs.svg)](https://badge.fury.io/nu/Cdklabs.CdkMonitoringConstructs)
[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/cdklabs/cdk-monitoring-constructs)
[![Mergify](https://img.shields.io/endpoint.svg?url=https://gh.mergify.io/badges/cdklabs/cdk-monitoring-constructs&style=flat)](https://mergify.io)

Easy-to-use CDK constructs for monitoring your AWS infrastructure with [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/).

* Easily add commonly-used alarms using predefined properties
* Generate concise CloudWatch dashboards that indicate your alarms
* Extend the library with your own extensions or custom metrics
* Consume the library in multiple supported languages

## Installation

<details><summary><strong>TypeScript</strong></summary>

> https://www.npmjs.com/package/cdk-monitoring-constructs

In your `package.json`:

```json
{
  "dependencies": {
    "cdk-monitoring-constructs": "^7.0.0",

    // peer dependencies of cdk-monitoring-constructs
    "aws-cdk-lib": "^2.112.0",
    "constructs": "^10.0.5"

    // ...your other dependencies...
  }
}
```

</details><details><summary><strong>Java</strong></summary>

See https://mvnrepository.com/artifact/io.github.cdklabs/cdkmonitoringconstructs

</details><details><summary><strong>Python</strong></summary>

See https://pypi.org/project/cdk-monitoring-constructs/

</details><details><summary><strong>C#</strong></summary>

See https://www.nuget.org/packages/Cdklabs.CdkMonitoringConstructs/

</details>

## Features

You can browse the documentation at https://constructs.dev/packages/cdk-monitoring-constructs/

| Item | Monitoring | Alarms | Notes |
| ---- | ---------- | ------ | ----- |
| AWS API Gateway (REST API) (`.monitorApiGateway()`) | TPS, latency, errors | Latency, error count/rate, low/high TPS | To see metrics, you have to enable Advanced Monitoring |
| AWS API Gateway V2 (HTTP API) (`.monitorApiGatewayV2HttpApi()`) | TPS, latency, errors | Latency, error count/rate, low/high TPS | To see route level metrics, you have to enable Advanced Monitoring |
| AWS AppSync (GraphQL API) (`.monitorAppSyncApi()`) | TPS, latency, errors | Latency, error count/rate, low/high TPS | |
| Amazon Aurora (`.monitorAuroraCluster()`) | Query duration, connections, latency, CPU usage, Serverless Database Capacity | Connections, Serverless Database Capacity and CPU usage | |
| AWS Billing (`.monitorBilling()`) | AWS account cost | Total cost (anomaly) | [Requires enabling](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/gs_monitor_estimated_charges_with_cloudwatch.html#gs_turning_on_billing_metrics) the **Receive Billing Alerts** option in AWS Console / Billing Preferences |
| AWS Certificate Manager (`.monitorCertificate()`) | Certificate expiration | Days until expiration | |
| AWS CloudFront (`.monitorCloudFrontDistribution()`) | TPS, traffic, latency, errors | Error rate, low/high TPS | |
| AWS CloudWatch Logs (`.monitorLog()`) | Patterns present in the log group | Minimum incoming logs | |
| AWS CloudWatch Synthetics Canary (`.monitorSyntheticsCanary()`) | Latency, error count/rate | Error count/rate, latency | |
| AWS CodeBuild (`.monitorCodeBuildProject()`) | Build counts (total, successful, failed), failed rate, duration | Failed build count/rate, duration | |
| AWS DocumentDB (`.monitorDocumentDbCluster()`) | CPU, throttling, read/write latency, transactions, cursors | CPU | |
| AWS DynamoDB (`.monitorDynamoTable()`) | Read and write capacity provisioned / used | Consumed capacity, throttling, latency, errors | |
| AWS DynamoDB Global Secondary Index (`.monitorDynamoTableGlobalSecondaryIndex()`) | Read and write capacity, indexing progress, throttled events | | |
| AWS EC2 (`.monitorEC2Instances()`) | CPU, disk operations, network | | |
| AWS EC2 Auto Scaling Groups (`.monitorAutoScalingGroup()`) | Group size, instance status | | |
| AWS ECS (`.monitorFargateService()`, `.monitorEc2Service()`, `.monitorSimpleFargateService()`, `monitorSimpleEc2Service()`, `.monitorQueueProcessingFargateService()`, `.monitorQueueProcessingEc2Service()`) | System resources and task health | Unhealthy task count, running tasks count, CPU/memory usage, and bytes processed by load balancer (if any) | Use for ecs-patterns load balanced ec2/fargate constructs (NetworkLoadBalancedEc2Service, NetworkLoadBalancedFargateService, ApplicationLoadBalancedEc2Service, ApplicationLoadBalancedFargateService) |
| AWS ElastiCache (`.monitorElastiCacheCluster()`) | CPU/memory usage, evictions and connections | CPU, memory, items count | |
| AWS Glue (`.monitorGlueJob()`) | Traffic, job status, memory/CPU usage | Failed/killed task count/rate | |
| AWS Kinesis Data Analytics (`.monitorKinesisDataAnalytics`) | Up/Downtime, CPU/memory usage, KPU usage, checkpoint metrics, and garbage collection metrics | Downtime, full restart count | |
| AWS Kinesis Data Stream (`.monitorKinesisDataStream()`) | Put/Get/Incoming Record/s and Throttling | Throttling, throughput, iterator max age | |
| AWS Kinesis Firehose (`.monitorKinesisFirehose()`) | Number of records, requests, latency, throttling | Throttling | |
| AWS Lambda (`.monitorLambdaFunction()`) | Latency, errors, iterator max age | Latency, errors, throttles, iterator max age | Optional Lambda Insights metrics (opt-in) support |
| AWS Load Balancing (`.monitorNetworkLoadBalancer()`, `.monitorFargateApplicationLoadBalancer()`, `.monitorFargateNetworkLoadBalancer()`, `.monitorEc2ApplicationLoadBalancer()`, `.monitorEc2NetworkLoadBalancer()`) | System resources and task health | Unhealthy task count, running tasks count, (for Fargate/Ec2 apps) CPU/memory usage | Use for FargateService or Ec2Service backed by a NetworkLoadBalancer or ApplicationLoadBalancer |
| AWS OpenSearch/Elasticsearch (`.monitorOpenSearchCluster()`, `.monitorElasticsearchCluster()`) | Indexing and search latency, disk/memory/CPU usage | Indexing and search latency, disk/memory/CPU usage, cluster status, KMS keys | |
| AWS RDS (`.monitorRdsCluster()`) | Query duration, connections, latency, disk/CPU usage | Connections, disk and CPU usage | |
| AWS RDS (`.monitorRdsInstance()`) | Query duration, connections, latency, disk/CPU usage | Connections, disk and CPU usage | |
| AWS Redshift (`.monitorRedshiftCluster()`) | Query duration, connections, latency, disk/CPU usage | Query duration, connections, disk and CPU usage | |
| AWS S3 Bucket (`.monitorS3Bucket()`) | Bucket size and number of objects | | |
| AWS SecretsManager (`.monitorSecretsManager()`) | Max secret count, min secret sount, secret count change | Min/max secret count or change in secret count | |
| AWS SecretsManager Secret (`.monitorSecretsManagerSecret()`) | Days since last rotation | Days since last change or rotation | |
| AWS SNS Topic (`.monitorSnsTopic()`) | Message count, size, failed notifications | Failed notifications, min/max published messages | |
| AWS SQS Queue (`.monitorSqsQueue()`, `.monitorSqsQueueWithDlq()`) | Message count, age, size | Message count, age, DLQ incoming messages | |
| AWS Step Functions (`.monitorStepFunction()`, `.monitorStepFunctionActivity()`, `monitorStepFunctionLambdaIntegration()`, `.monitorStepFunctionServiceIntegration()`) | Execution count and breakdown per state | Duration, failed, failed rate, aborted, throttled, timed out executions | |
| AWS Web Application Firewall (`.monitorWebApplicationFirewallAclV2()`) | Allowed/blocked requests | Blocked requests count/rate | |
| FluentBit (`.monitorFluentBit()`) | Num of input records, Output failures & retries, Filter metrics, Storage metrics | | FluentBit needs proper configuration with  metrics enabled: [Official sample configuration](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/send-fb-internal-metrics-to-cw). This function creates MetricFilters to publish all FluentBit metrics. |
| Custom metrics (`.monitorCustom()`) | Addition of custom metrics into the dashboard (each group is a widget) | | Supports anomaly detection |

## Getting started

### Create a facade

*Important note*: **Please, do NOT import anything from the `/dist/lib` package.** This is unsupported and might break any time.

1. Create an instance of `MonitoringFacade`, which is the main entrypoint.
2. Call methods on the facade like `.monitorLambdaFunction()` and chain them together to define your monitors. You can also use methods to add your own widgets, headers of various sizes, and more.

For examples of monitoring different resources, refer to [the unit tests](https://github.com/cdklabs/cdk-monitoring-constructs/tree/main/test/monitoring).

```python
export interface MonitoringStackProps extends DeploymentStackProps {
  // ...
}

// This could be in the same stack as your resources, as a nested stack, or a separate stack as you see fit
export class MonitoringStack extends DeploymentStack {
  constructor(parent: App, name: string, props: MonitoringStackProps) {
    super(parent, name, props);

    const monitoring = new MonitoringFacade(this, "Monitoring", {
      // Defaults are provided for these, but they can be customized as desired
      metricFactoryDefaults: { ... },
      alarmFactoryDefaults: { ... },
      dashboardFactory: { ... },
    });

    // Monitor your resources
    monitoring
      .addLargeHeader("Storage")
      .monitorDynamoTable({ /* Monitor a DynamoDB table */ })
      .monitorDynamoTable({ /* and a different table */ })
      .monitorLambdaFunction({ /* and a Lambda function */ })
      .monitorCustom({ /* and some arbitrary metrics in CloudWatch */ })
      // ... etc.
  }
}
```

### Customize actions

Alarms should have an action setup, otherwise they are not very useful. Currently, we support notifying an SNS topic.

```python
const onAlarmTopic = new Topic(this, "AlarmTopic");

const monitoring = new MonitoringFacade(this, "Monitoring", {
  // ...other props
  alarmFactoryDefaults: {
    // ....other props
    action: new SnsAlarmActionStrategy({ onAlarmTopic }),
  },
});
```

You can override the default topic for any alarm like this:

```python
monitoring
  .monitorSomething(something, {
    addSomeAlarm: {
      Warning: {
        // ...other props
        threshold: 42,
        actionOverride: new SnsAlarmActionStrategy({ onAlarmTopic }),
      }
    }
  });
```

### Custom metrics

For simply adding some custom metrics, you can use `.monitorCustom()` and specify your own title and metric groups.
Each metric group will be rendered as a single graph widget, and all widgets will be placed next to each other.
All the widgets will have the same size, which is chosen based on the number of groups to maximize dashboard space usage.

Custom metric monitoring can be created for simple metrics, simple metrics with anomaly detection and search metrics.
The first two also support alarming.

Below we are listing a couple of examples. Let us assume that there are three existing metric variables: `m1`, `m2`, `m3`.
They can either be created by hand (`new Metric({...})`) or (preferably) by using `metricFactory` (that can be obtained from facade).
The advantage of using the shared `metricFactory` is that you do not need to worry about period, etc.

```python
// create metrics manually
const m1 = new Metric(/* ... */);
```

```python
const metricFactory = monitoringFacade.createMetricFactory();

// create metrics using metric factory
const m1 = metricFactory.createMetric(/* ... */);
```

#### Example: metric with anomaly detection

In this case, only one metric is supported.
Multiple metrics cannot be rendered with anomaly detection in a single widget due to a CloudWatch limitation.

```python
monitorCustom({
  title: "Metric with anomaly detection",
  metricGroups: [
    {
      metric: m1,
      anomalyDetectionStandardDeviationToRender: 3
    }
  ]
})
```

Adding an alarm:

```python
monitorCustom({
  title: "Metric with anomaly detection and alarm",
  metricGroups: [
    {
      metric: m1,
      alarmFriendlyName: "MetricWithAnomalyDetectionAlarm",
      anomalyDetectionStandardDeviationToRender: 3,
      addAlarmOnAnomaly: {
        Warning: {
          standardDeviationForAlarm: 4,
          alarmWhenAboveTheBand: true,
          alarmWhenBelowTheBand: true
        }
      }
    }
  ]
})
```

#### Example: search metrics

```python
monitorCustom({
  title: "Metric search",
  metricGroups: [
    {
      searchQuery: "My.Prefix.",
      dimensionsMap: {
        FirstDimension: "FirstDimensionValue",
        // Allow any value for the given dimension (pardon the weird typing to satisfy DimensionsMap)
        SecondDimension: undefined as unknown as string
      }
      statistic: MetricStatistic.SUM,
    }
  ]
})
```

Search metrics do not support setting an alarm, which is a CloudWatch limitation.

### Route53 Health Checks

Route53 has [strict requirements](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/health-checks-types.html) as to which alarms are allowed to be referenced in Health Checks.
You adjust the metric for an alarm so that it can be used in a Route53 Health Checks as follows:

```python
monitoring
  .monitorSomething(something, {
    addSomeAlarm: {
      Warning: {
        // ...other props
        metricAdjuster: Route53HealthCheckMetricAdjuster.INSTANCE,
      }
    }
  });
```

This will ensure the alarm can be used on a Route53 Health Check or otherwise throw an `Error` indicating why the alarm can't be used.
In order to easily find your Route53 Health Check alarms later on, you can apply a custom tag to them as follows:

```python
import { CfnHealthCheck } from "aws-cdk-lib/aws-route53";

monitoring
  .monitorSomething(something, {
    addSomeAlarm: {
      Warning: {
        // ...other props
        customTags: ["route53-health-check"],
        metricAdjuster: Route53HealthCheckMetricAdjuster.INSTANCE,
      }
    }
  });

const alarms = monitoring.createdAlarmsWithTag("route53-health-check");

const healthChecks = alarms.map(({ alarm }) => {
  const id = getHealthCheckConstructId(alarm);

  return new CfnHealthCheck(scope, id, {
    healthCheckConfig: {
      // ...other props
      type: "CLOUDWATCH_METRIC",
      alarmIdentifier: {
        name: alarm.alarmName,
        region: alarm.stack.region,
      },
    },
  });
});
```

### Custom monitoring segments

If you want even more flexibility, you can create your own segment.

This is a general procedure on how to do it:

1. Extend the `Monitoring` class
2. Override the `widgets()` method (and/or similar ones)
3. Leverage the metric factory and alarm factory provided by the base class (you can create additional factories, if you will)
4. Add all alarms to `.addAlarm()` so they are visible to the user and being placed on the alarm summary dashboard

Both of these monitoring base classes are dashboard segments, so you can add them to your monitoring by calling `.addSegment()` on the `MonitoringFacade`.

### Modifying or omitting widgets from default dashboard segments

While the dashboard widgets defined in the library are meant to cover most use cases, they might not be what you're looking for.

To modify the widgets:

1. Extend the appropriate `Monitoring` class (e.g., `LambdaFunctionMonitoring` for `monitorLambdaFunction`) and override the relevant methods (e.g., `widgets`):

   ```python
   export class MyCustomizedLambdaFunctionMonitoring extends LambdaFunctionMonitoring {
     widgets(): IWidget[] {
       return [
         // Whatever widgets you want instead of what LambdaFunctionMonitoring has
       ];
     }
   }
   ```
2. Use the facade's `addSegment` method with your custom class:

   ```python
   declare const facade: MonitoringFacade;

   facade.addSegment(new MyCustomizedLambdaFunctionMonitoring(facade, {
     // Props for LambdaFunctionMonitoring
   }));
   ```

### Custom dashboards

If you want *even* more flexibility, you can take complete control over dashboard generation by leveraging dynamic dashboarding features. This allows you to create an arbitrary number of dashboards while configuring each of them separately. You can do this in three simple steps:

1. Create a dynamic dashboard factory
2. Create `IDynamicDashboardSegment` implementations
3. Add Dynamic Segments to your `MonitoringFacade`

#### Create a dynamic dashboard factory

The below code sample will generate two dashboards with the following names:

* ExampleDashboards-HostedService
* ExampleDashboards-Infrastructure

```python
// create the dynamic dashboard factory.
const factory = new DynamicDashboardFactory(stack, "DynamicDashboards", {
  dashboardNamePrefix: "ExampleDashboards",
  dashboardConfigs: [
    // 'name' is the minimum required configuration
    { name: "HostedService" },
    // below is an example of additional dashboard-specific config options
    {
      name: "Infrastructure",
      range: Duration.hours(3),
      periodOverride: PeriodOverride.AUTO,
      renderingPreference: DashboardRenderingPreference.BITMAP_ONLY
    },
  ],
});
```

#### Create `IDynamicDashboardSegment` implementations

For each construct you want monitored, you will need to create an implementation of an `IDynamicDashboardSegment`. The following is a basic reference implementation as an example:

```python
export enum DashboardTypes {
  HostedService = "HostedService",
  Infrastructure = "Infrastructure",
}

class ExampleSegment implements IDynamicDashboardSegment {
  widgetsForDashboard(name: string): IWidget[] {
    // this logic is what's responsible for allowing your dynamic segment to return
    // different widgets for different dashboards
    switch (name) {
      case DashboardTypes.HostedService:
        return [new TextWidget({ markdown: "This shows metrics for your service hosted on AWS Infrastructure" })];
      case DashboardTypes.Infrastructure:
        return [new TextWidget({ markdown: "This shows metrics for the AWS Infrastructure supporting your hosted service" })];
      default:
        throw new Error("Unexpected dashboard name!");
    }
  }
}
```

#### Add Dynamic Segments to MonitoringFacade

When you have instances of an `IDynamicDashboardSegment` to use, they can be added to your dashboard like this:

```python
monitoring.addDynamicSegment(new ExampleSegment());
```

Now, this widget will be added to both dashboards and will show different content depending on the dashboard. Using the above example code, two dashboards will be generated with the following content:

* Dashboard Name: "ExampleDashboards-HostedService"

  * Content: "This shows metrics for your service hosted on AWS Infrastructure"
* Dashboard Name: "ExampleDashboards-Infrastructure"

  * Content: "This shows metrics for the AWS Infrastructure supporting your hosted service"

### Cross-account cross-Region Dashboards

Facades can be configured for different regions/accounts as a whole:

```python
new MonitoringFacade(stack, "Monitoring", {
  metricFactoryDefaults: {
    // Different region/account than what you're deploying to
    region: "us-west-2",
    account: "01234567890",
  }
});
```

Or at a more granular level:

```python
monitoring
  .monitorDynamoTable({
    // Table from the same account/region
    table: Table.fromTableName(stack, "ImportedTable", "MyTableName"),
  })
  .monitorDynamoTable({
    // Table from another account/region
    table: Table.fromTableArn(
      stack,
      "XaXrImportedTable",
      "arn:aws:dynamodb:us-west-2:01234567890:table/my-other-table",
    ),
    region: "us-west-2",
    account: "01234567890",
  });
```

The order of precedence of the region/account values is:

1. The individual metric factory's props (e.g. via the `monitorDynamoTable` props).
2. The facade's `metricFactoryDefaults` props.
3. The region/account that the stack is deployed to.

Note that while this allows for cross-account cross-Region dashboarding, cross-Region alarming is not supported by CloudWatch.

### Monitoring scopes

You can monitor complete CDK construct scopes using an aspect. It will automatically discover all monitorable resources within the scope recursively and add them to your dashboard.

```python
monitoring.monitorScope(stack, {
  // With optional configuration
  lambda: {
    props: {
      addLatencyP50Alarm: {
        Critical: { maxLatency: Duration.seconds(10) },
      },
    },
  },

  // Some resources that aren't dependent on nodes (e.g. general metrics across instances/account) may be included
  // by default, which can be explicitly disabled.
  billing: { enabled: false },
  ec2: { enabled: false },
  elasticCache: { enabled: false },
});
```

## Contributing

See [CONTRIBUTING](CONTRIBUTING.md) for more information.

## Security policy

See [SECURITY](SECURITY.md) for more information.

## License

This project is licensed under the Apache-2.0 License.
'''
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)

import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

import typeguard
from importlib.metadata import version as _metadata_package_version
TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])

def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
    if TYPEGUARD_MAJOR_VERSION <= 2:
        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
    else:
        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
           pass
        else:
            if TYPEGUARD_MAJOR_VERSION == 3:
                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
            else:
                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore

from ._jsii import *

import aws_cdk as _aws_cdk_ceddda9d
import aws_cdk.aws_apigateway as _aws_cdk_aws_apigateway_ceddda9d
import aws_cdk.aws_apigatewayv2 as _aws_cdk_aws_apigatewayv2_ceddda9d
import aws_cdk.aws_appsync as _aws_cdk_aws_appsync_ceddda9d
import aws_cdk.aws_autoscaling as _aws_cdk_aws_autoscaling_ceddda9d
import aws_cdk.aws_certificatemanager as _aws_cdk_aws_certificatemanager_ceddda9d
import aws_cdk.aws_cloudfront as _aws_cdk_aws_cloudfront_ceddda9d
import aws_cdk.aws_cloudwatch as _aws_cdk_aws_cloudwatch_ceddda9d
import aws_cdk.aws_cloudwatch_actions as _aws_cdk_aws_cloudwatch_actions_ceddda9d
import aws_cdk.aws_codebuild as _aws_cdk_aws_codebuild_ceddda9d
import aws_cdk.aws_docdb as _aws_cdk_aws_docdb_ceddda9d
import aws_cdk.aws_dynamodb as _aws_cdk_aws_dynamodb_ceddda9d
import aws_cdk.aws_ecs as _aws_cdk_aws_ecs_ceddda9d
import aws_cdk.aws_ecs_patterns as _aws_cdk_aws_ecs_patterns_ceddda9d
import aws_cdk.aws_elasticloadbalancingv2 as _aws_cdk_aws_elasticloadbalancingv2_ceddda9d
import aws_cdk.aws_elasticsearch as _aws_cdk_aws_elasticsearch_ceddda9d
import aws_cdk.aws_lambda as _aws_cdk_aws_lambda_ceddda9d
import aws_cdk.aws_logs as _aws_cdk_aws_logs_ceddda9d
import aws_cdk.aws_opensearchservice as _aws_cdk_aws_opensearchservice_ceddda9d
import aws_cdk.aws_rds as _aws_cdk_aws_rds_ceddda9d
import aws_cdk.aws_s3 as _aws_cdk_aws_s3_ceddda9d
import aws_cdk.aws_secretsmanager as _aws_cdk_aws_secretsmanager_ceddda9d
import aws_cdk.aws_sns as _aws_cdk_aws_sns_ceddda9d
import aws_cdk.aws_sqs as _aws_cdk_aws_sqs_ceddda9d
import aws_cdk.aws_stepfunctions as _aws_cdk_aws_stepfunctions_ceddda9d
import aws_cdk.aws_synthetics as _aws_cdk_aws_synthetics_ceddda9d
import aws_cdk.aws_wafv2 as _aws_cdk_aws_wafv2_ceddda9d
import constructs as _constructs_77d1e7e8


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AddAlarmProps",
    jsii_struct_bases=[],
    name_mapping={
        "alarm_description": "alarmDescription",
        "alarm_name_suffix": "alarmNameSuffix",
        "comparison_operator": "comparisonOperator",
        "threshold": "threshold",
        "treat_missing_data": "treatMissingData",
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_dedupe_string_suffix": "alarmDedupeStringSuffix",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "disambiguator": "disambiguator",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
    },
)
class AddAlarmProps:
    def __init__(
        self,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Properties necessary to create a single alarm and configure it.

        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b02dfad72d85267c914e96c01bf8fa0ce42c19f927e7ec13f79575e8eb14beb)
            check_type(argname="argument alarm_description", value=alarm_description, expected_type=type_hints["alarm_description"])
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument comparison_operator", value=comparison_operator, expected_type=type_hints["comparison_operator"])
            check_type(argname="argument threshold", value=threshold, expected_type=type_hints["threshold"])
            check_type(argname="argument treat_missing_data", value=treat_missing_data, expected_type=type_hints["treat_missing_data"])
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_dedupe_string_suffix", value=alarm_dedupe_string_suffix, expected_type=type_hints["alarm_dedupe_string_suffix"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_description": alarm_description,
            "alarm_name_suffix": alarm_name_suffix,
            "comparison_operator": comparison_operator,
            "threshold": threshold,
            "treat_missing_data": treat_missing_data,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_dedupe_string_suffix is not None:
            self._values["alarm_dedupe_string_suffix"] = alarm_dedupe_string_suffix
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id

    @builtins.property
    def alarm_description(self) -> builtins.str:
        '''(experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.

        :stability: experimental
        '''
        result = self._values.get("alarm_description")
        assert result is not None, "Required property 'alarm_description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_name_suffix(self) -> builtins.str:
        '''(experimental) Suffix added to base alarm name.

        Alarm names need to be unique.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_suffix")
        assert result is not None, "Required property 'alarm_name_suffix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def comparison_operator(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :stability: experimental
        '''
        result = self._values.get("comparison_operator")
        assert result is not None, "Required property 'comparison_operator' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator, result)

    @builtins.property
    def threshold(self) -> jsii.Number:
        '''(experimental) Threshold to alarm on.

        :stability: experimental
        '''
        result = self._values.get("threshold")
        assert result is not None, "Required property 'threshold' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def treat_missing_data(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData:
        '''(experimental) Behaviour in case the metric data is missing.

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data")
        assert result is not None, "Required property 'treat_missing_data' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData, result)

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default action strategy.

        :default: - default action will be used

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_dedupe_string_suffix(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix.

        This allows you to specify the same dedupe string for a family of alarms.
        Cannot be defined at the same time as alarmDedupeStringOverride.

        :default: - undefined (no suffix)

        :stability: experimental
        '''
        result = self._values.get("alarm_dedupe_string_suffix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''(experimental) Disambiguator is a string that differentiates this alarm from other similar ones.

        :default: - undefined (no disambiguator)

        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - Same as datapointsToAlarm.

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, an artificial composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AddAlarmProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AddCompositeAlarmProps",
    jsii_struct_bases=[],
    name_mapping={
        "disambiguator": "disambiguator",
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "actions_suppressor": "actionsSuppressor",
        "actions_suppressor_extension_period": "actionsSuppressorExtensionPeriod",
        "actions_suppressor_wait_period": "actionsSuppressorWaitPeriod",
        "alarm_dedupe_string_suffix": "alarmDedupeStringSuffix",
        "alarm_description": "alarmDescription",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "alarm_name_suffix": "alarmNameSuffix",
        "composite_operator": "compositeOperator",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "fill_alarm_range": "fillAlarmRange",
        "runbook_link": "runbookLink",
    },
)
class AddCompositeAlarmProps:
    def __init__(
        self,
        *,
        disambiguator: builtins.str,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
        actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        alarm_name_suffix: typing.Optional[builtins.str] = None,
        composite_operator: typing.Optional["CompositeAlarmOperator"] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        runbook_link: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Properties necessary to create a composite alarm and configure it.

        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param actions_suppressor: (experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state. Default: - no suppressor alarm
        :param actions_suppressor_extension_period: (experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param actions_suppressor_wait_period: (experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible. Default: - no description
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique. Default: - no suffix
        :param composite_operator: (experimental) Logical operator used to aggregate the status individual alarms. Default: - OR
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eeb5f357e7348a2956ac5d7eeeb946ec27a21382a4de10c67d98c171fd8e9ab9)
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument actions_suppressor", value=actions_suppressor, expected_type=type_hints["actions_suppressor"])
            check_type(argname="argument actions_suppressor_extension_period", value=actions_suppressor_extension_period, expected_type=type_hints["actions_suppressor_extension_period"])
            check_type(argname="argument actions_suppressor_wait_period", value=actions_suppressor_wait_period, expected_type=type_hints["actions_suppressor_wait_period"])
            check_type(argname="argument alarm_dedupe_string_suffix", value=alarm_dedupe_string_suffix, expected_type=type_hints["alarm_dedupe_string_suffix"])
            check_type(argname="argument alarm_description", value=alarm_description, expected_type=type_hints["alarm_description"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument composite_operator", value=composite_operator, expected_type=type_hints["composite_operator"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "disambiguator": disambiguator,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if actions_suppressor is not None:
            self._values["actions_suppressor"] = actions_suppressor
        if actions_suppressor_extension_period is not None:
            self._values["actions_suppressor_extension_period"] = actions_suppressor_extension_period
        if actions_suppressor_wait_period is not None:
            self._values["actions_suppressor_wait_period"] = actions_suppressor_wait_period
        if alarm_dedupe_string_suffix is not None:
            self._values["alarm_dedupe_string_suffix"] = alarm_dedupe_string_suffix
        if alarm_description is not None:
            self._values["alarm_description"] = alarm_description
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if alarm_name_suffix is not None:
            self._values["alarm_name_suffix"] = alarm_name_suffix
        if composite_operator is not None:
            self._values["composite_operator"] = composite_operator
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link

    @builtins.property
    def disambiguator(self) -> builtins.str:
        '''(experimental) Disambiguator is a string that differentiates this alarm from other similar ones.

        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        assert result is not None, "Required property 'disambiguator' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default action strategy.

        :default: - default action will be used

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def actions_suppressor(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm]:
        '''(experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state.

        :default: - no suppressor alarm

        :stability: experimental
        '''
        result = self._values.get("actions_suppressor")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm], result)

    @builtins.property
    def actions_suppressor_extension_period(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state.

        After this time, the composite alarm performs its actions.

        :default: - 60 seconds

        :stability: experimental
        '''
        result = self._values.get("actions_suppressor_extension_period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def actions_suppressor_wait_period(
        self,
    ) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state.

        After this time, the composite alarm performs its actions.

        :default: - 60 seconds

        :stability: experimental
        '''
        result = self._values.get("actions_suppressor_wait_period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def alarm_dedupe_string_suffix(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix.

        This allows you to specify the same dedupe string for a family of alarms.
        Cannot be defined at the same time as alarmDedupeStringOverride.

        :default: - undefined (no suffix)

        :stability: experimental
        '''
        result = self._values.get("alarm_dedupe_string_suffix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_description(self) -> typing.Optional[builtins.str]:
        '''(experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.

        :default: - no description

        :stability: experimental
        '''
        result = self._values.get("alarm_description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_suffix(self) -> typing.Optional[builtins.str]:
        '''(experimental) Suffix added to base alarm name.

        Alarm names need to be unique.

        :default: - no suffix

        :stability: experimental
        '''
        result = self._values.get("alarm_name_suffix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def composite_operator(self) -> typing.Optional["CompositeAlarmOperator"]:
        '''(experimental) Logical operator used to aggregate the status individual alarms.

        :default: - OR

        :stability: experimental
        '''
        result = self._values.get("composite_operator")
        return typing.cast(typing.Optional["CompositeAlarmOperator"], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AddCompositeAlarmProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AgeAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AgeAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: "AlarmFactory") -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2c73b9ece3b1f8ccae4e1b8b67589353cbf8cbfc367672eee37d943e25b0b46)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addDaysSinceUpdateAlarm")
    def add_days_since_update_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["DaysSinceUpdateThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> "AlarmWithAnnotation":
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f6c59609b0d5ad31b391a231c262ad88ec6071638bbc2c2f200e83726dff668)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast("AlarmWithAnnotation", jsii.invoke(self, "addDaysSinceUpdateAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addDaysToExpiryAlarm")
    def add_days_to_expiry_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["DaysToExpiryThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> "AlarmWithAnnotation":
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36376b2db790a761bdac57a3eae2e5c91a8908b1af40ecb90463c9ef6ef49cfd)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast("AlarmWithAnnotation", jsii.invoke(self, "addDaysToExpiryAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addIteratorMaxAgeAlarm")
    def add_iterator_max_age_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxAgeThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> "AlarmWithAnnotation":
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3e8f044140c9c20c6e311a6b3f7d15c44e9f2ad885d9adb02bed8a8453b885fd)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast("AlarmWithAnnotation", jsii.invoke(self, "addIteratorMaxAgeAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxOffsetLagAlarm")
    def add_max_offset_lag_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxOffsetLagThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> "AlarmWithAnnotation":
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__278dcde210e24513baf8545edd5c36a214b0e167d71099667eb06b09a55a5e8a)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast("AlarmWithAnnotation", jsii.invoke(self, "addMaxOffsetLagAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> "AlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("AlarmFactory", jsii.get(self, "alarmFactory"))


class AlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        alarm_scope: _constructs_77d1e7e8.Construct,
        *,
        global_alarm_defaults: typing.Union["AlarmFactoryDefaults", typing.Dict[builtins.str, typing.Any]],
        global_metric_defaults: typing.Union["MetricFactoryDefaults", typing.Dict[builtins.str, typing.Any]],
        local_alarm_name_prefix: builtins.str,
    ) -> None:
        '''
        :param alarm_scope: -
        :param global_alarm_defaults: 
        :param global_metric_defaults: 
        :param local_alarm_name_prefix: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d530f09f2bd1cb040202791761b41a5c66dd4f747bb728393746d98c8604ffca)
            check_type(argname="argument alarm_scope", value=alarm_scope, expected_type=type_hints["alarm_scope"])
        props = AlarmFactoryProps(
            global_alarm_defaults=global_alarm_defaults,
            global_metric_defaults=global_metric_defaults,
            local_alarm_name_prefix=local_alarm_name_prefix,
        )

        jsii.create(self.__class__, self, [alarm_scope, props])

    @jsii.member(jsii_name="addAlarm")
    def add_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> "AlarmWithAnnotation":
        '''
        :param metric: -
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76f30a6274e169a72149ce2908aacf78a821a45ce1227e62e977bcdcc11a9ad6)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
        props = AddAlarmProps(
            alarm_description=alarm_description,
            alarm_name_suffix=alarm_name_suffix,
            comparison_operator=comparison_operator,
            threshold=threshold,
            treat_missing_data=treat_missing_data,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
        )

        return typing.cast("AlarmWithAnnotation", jsii.invoke(self, "addAlarm", [metric, props]))

    @jsii.member(jsii_name="addCompositeAlarm")
    def add_composite_alarm(
        self,
        alarms: typing.Sequence[typing.Union["AlarmWithAnnotation", typing.Dict[builtins.str, typing.Any]]],
        *,
        disambiguator: builtins.str,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
        actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        alarm_name_suffix: typing.Optional[builtins.str] = None,
        composite_operator: typing.Optional["CompositeAlarmOperator"] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        runbook_link: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm:
        '''
        :param alarms: -
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param actions_suppressor: (experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state. Default: - no suppressor alarm
        :param actions_suppressor_extension_period: (experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param actions_suppressor_wait_period: (experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible. Default: - no description
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique. Default: - no suffix
        :param composite_operator: (experimental) Logical operator used to aggregate the status individual alarms. Default: - OR
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b703e3bbae3158b7391198d1073fa418378a8c7827bae974676303ce1b89aca4)
            check_type(argname="argument alarms", value=alarms, expected_type=type_hints["alarms"])
        props = AddCompositeAlarmProps(
            disambiguator=disambiguator,
            action_override=action_override,
            actions_enabled=actions_enabled,
            actions_suppressor=actions_suppressor,
            actions_suppressor_extension_period=actions_suppressor_extension_period,
            actions_suppressor_wait_period=actions_suppressor_wait_period,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description=alarm_description,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            alarm_name_suffix=alarm_name_suffix,
            composite_operator=composite_operator,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            fill_alarm_range=fill_alarm_range,
            runbook_link=runbook_link,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm, jsii.invoke(self, "addCompositeAlarm", [alarms, props]))

    @jsii.member(jsii_name="createAnnotation")
    def _create_annotation(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: "IAlarmActionStrategy",
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, jsii.invoke(self, "createAnnotation", [props]))

    @jsii.member(jsii_name="determineAction")
    def _determine_action(
        self,
        disambiguator: typing.Optional[builtins.str] = None,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
    ) -> "IAlarmActionStrategy":
        '''
        :param disambiguator: -
        :param action_override: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1806c2b56e06aca7469b8b7c8eb99bf73911d1cec0e7c65dbb1a54959252e7ad)
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
        return typing.cast("IAlarmActionStrategy", jsii.invoke(self, "determineAction", [disambiguator, action_override]))

    @jsii.member(jsii_name="determineActionsEnabled")
    def _determine_actions_enabled(
        self,
        actions_enabled: typing.Optional[builtins.bool] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.bool:
        '''
        :param actions_enabled: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d529ec60c6a287047e76852ff88beeacfbb308e0bc5960475561481b2edda7b)
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(builtins.bool, jsii.invoke(self, "determineActionsEnabled", [actions_enabled, disambiguator]))

    @jsii.member(jsii_name="determineCompositeAlarmRule")
    def _determine_composite_alarm_rule(
        self,
        alarms: typing.Sequence[typing.Union["AlarmWithAnnotation", typing.Dict[builtins.str, typing.Any]]],
        *,
        disambiguator: builtins.str,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
        actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        alarm_name_suffix: typing.Optional[builtins.str] = None,
        composite_operator: typing.Optional["CompositeAlarmOperator"] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        runbook_link: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule:
        '''
        :param alarms: -
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param actions_suppressor: (experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state. Default: - no suppressor alarm
        :param actions_suppressor_extension_period: (experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param actions_suppressor_wait_period: (experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible. Default: - no description
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique. Default: - no suffix
        :param composite_operator: (experimental) Logical operator used to aggregate the status individual alarms. Default: - OR
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85e1f9c182eac394694acbb2e460d9b69a7b911e259ed7551b0d66751d24bfb7)
            check_type(argname="argument alarms", value=alarms, expected_type=type_hints["alarms"])
        props = AddCompositeAlarmProps(
            disambiguator=disambiguator,
            action_override=action_override,
            actions_enabled=actions_enabled,
            actions_suppressor=actions_suppressor,
            actions_suppressor_extension_period=actions_suppressor_extension_period,
            actions_suppressor_wait_period=actions_suppressor_wait_period,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description=alarm_description,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            alarm_name_suffix=alarm_name_suffix,
            composite_operator=composite_operator,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            fill_alarm_range=fill_alarm_range,
            runbook_link=runbook_link,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule, jsii.invoke(self, "determineCompositeAlarmRule", [alarms, props]))

    @jsii.member(jsii_name="generateDescription")
    def _generate_description(
        self,
        alarm_description: builtins.str,
        alarm_description_override: typing.Optional[builtins.str] = None,
        runbook_link_override: typing.Optional[builtins.str] = None,
        documentation_link_override: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''
        :param alarm_description: -
        :param alarm_description_override: -
        :param runbook_link_override: -
        :param documentation_link_override: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ce541a1f1d438233dfb2c3ba4d9fb2f331b534bd593e765a92f9dc1948326d3)
            check_type(argname="argument alarm_description", value=alarm_description, expected_type=type_hints["alarm_description"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument runbook_link_override", value=runbook_link_override, expected_type=type_hints["runbook_link_override"])
            check_type(argname="argument documentation_link_override", value=documentation_link_override, expected_type=type_hints["documentation_link_override"])
        return typing.cast(builtins.str, jsii.invoke(self, "generateDescription", [alarm_description, alarm_description_override, runbook_link_override, documentation_link_override]))

    @jsii.member(jsii_name="joinDescriptionParts")
    def _join_description_parts(self, *parts: builtins.str) -> builtins.str:
        '''
        :param parts: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46cc2166df47572e3a247df8eb1593665f6107460437a71618d805f31276fa91)
            check_type(argname="argument parts", value=parts, expected_type=typing.Tuple[type_hints["parts"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(builtins.str, jsii.invoke(self, "joinDescriptionParts", [*parts]))

    @builtins.property
    @jsii.member(jsii_name="alarmNamingStrategy")
    def _alarm_naming_strategy(self) -> "IAlarmNamingStrategy":
        '''
        :stability: experimental
        '''
        return typing.cast("IAlarmNamingStrategy", jsii.get(self, "alarmNamingStrategy"))

    @builtins.property
    @jsii.member(jsii_name="alarmScope")
    def _alarm_scope(self) -> _constructs_77d1e7e8.Construct:
        '''
        :stability: experimental
        '''
        return typing.cast(_constructs_77d1e7e8.Construct, jsii.get(self, "alarmScope"))

    @builtins.property
    @jsii.member(jsii_name="globalAlarmDefaults")
    def _global_alarm_defaults(self) -> "AlarmFactoryDefaults":
        '''
        :stability: experimental
        '''
        return typing.cast("AlarmFactoryDefaults", jsii.get(self, "globalAlarmDefaults"))

    @builtins.property
    @jsii.member(jsii_name="globalMetricDefaults")
    def _global_metric_defaults(self) -> "MetricFactoryDefaults":
        '''
        :stability: experimental
        '''
        return typing.cast("MetricFactoryDefaults", jsii.get(self, "globalMetricDefaults"))

    @builtins.property
    @jsii.member(jsii_name="shouldUseDefaultDedupeForError")
    def should_use_default_dedupe_for_error(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "shouldUseDefaultDedupeForError"))

    @builtins.property
    @jsii.member(jsii_name="shouldUseDefaultDedupeForLatency")
    def should_use_default_dedupe_for_latency(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "shouldUseDefaultDedupeForLatency"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmFactoryDefaults",
    jsii_struct_bases=[],
    name_mapping={
        "actions_enabled": "actionsEnabled",
        "alarm_name_prefix": "alarmNamePrefix",
        "action": "action",
        "alarm_naming_strategy": "alarmNamingStrategy",
        "annotation_strategy": "annotationStrategy",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_processor": "dedupeStringProcessor",
        "disambiguator_action": "disambiguatorAction",
        "documentation_link": "documentationLink",
        "evaluation_periods": "evaluationPeriods",
        "runbook_link": "runbookLink",
        "use_default_dedupe_for_error": "useDefaultDedupeForError",
        "use_default_dedupe_for_latency": "useDefaultDedupeForLatency",
    },
)
class AlarmFactoryDefaults:
    def __init__(
        self,
        *,
        actions_enabled: typing.Union[builtins.bool, typing.Mapping[builtins.str, builtins.bool]],
        alarm_name_prefix: builtins.str,
        action: typing.Optional["IAlarmActionStrategy"] = None,
        alarm_naming_strategy: typing.Optional["IAlarmNamingStrategy"] = None,
        annotation_strategy: typing.Optional["IAlarmAnnotationStrategy"] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_processor: typing.Optional["IAlarmDedupeStringProcessor"] = None,
        disambiguator_action: typing.Optional[typing.Mapping[builtins.str, "IAlarmActionStrategy"]] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        use_default_dedupe_for_error: typing.Optional[builtins.bool] = None,
        use_default_dedupe_for_latency: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions for either all severities, or per severity.
        :param alarm_name_prefix: (experimental) Global prefix for all alarm names. This should be something unique to avoid potential collisions. This is ignored if an alarm's dedupeStringOverride is declared.
        :param action: (experimental) Default alarm action used for each alarm, unless it is overridden. Default: - no action.
        :param alarm_naming_strategy: (experimental) Custom strategy to name alarms. Default: - default behaviour (no change)
        :param annotation_strategy: (experimental) Custom strategy to create annotations for alarms. Default: - default annotations
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - 3
        :param dedupe_string_processor: (experimental) Custom strategy to process dedupe strings of the alarms. Default: - default behaviour (no change)
        :param disambiguator_action: (experimental) Optional alarm action for each disambiguator. Default: - Global alarm action if defined.
        :param documentation_link: (experimental) An optional link included in the generated ticket description body.
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param runbook_link: (experimental) An optional link included in the generated ticket description body.
        :param use_default_dedupe_for_error: (experimental) If this is defined as false and dedupeStringOverride is undefined, the alarm prefix will be part of the dedupe string. This essentially stops the dedupe of different errors together. Default: - undefined (true)
        :param use_default_dedupe_for_latency: (experimental) If this is defined as false and dedupeStringOverride is undefined, the alarm prefix will be part of the dedupe string. This essentially stops the dedupe of different latency issues together. Default: - undefined (true)

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce74e18bedccb1274dd309e1f81086fe1928a283e50611acef614538a67fea94)
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_name_prefix", value=alarm_name_prefix, expected_type=type_hints["alarm_name_prefix"])
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument alarm_naming_strategy", value=alarm_naming_strategy, expected_type=type_hints["alarm_naming_strategy"])
            check_type(argname="argument annotation_strategy", value=annotation_strategy, expected_type=type_hints["annotation_strategy"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_processor", value=dedupe_string_processor, expected_type=type_hints["dedupe_string_processor"])
            check_type(argname="argument disambiguator_action", value=disambiguator_action, expected_type=type_hints["disambiguator_action"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument use_default_dedupe_for_error", value=use_default_dedupe_for_error, expected_type=type_hints["use_default_dedupe_for_error"])
            check_type(argname="argument use_default_dedupe_for_latency", value=use_default_dedupe_for_latency, expected_type=type_hints["use_default_dedupe_for_latency"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "actions_enabled": actions_enabled,
            "alarm_name_prefix": alarm_name_prefix,
        }
        if action is not None:
            self._values["action"] = action
        if alarm_naming_strategy is not None:
            self._values["alarm_naming_strategy"] = alarm_naming_strategy
        if annotation_strategy is not None:
            self._values["annotation_strategy"] = annotation_strategy
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_processor is not None:
            self._values["dedupe_string_processor"] = dedupe_string_processor
        if disambiguator_action is not None:
            self._values["disambiguator_action"] = disambiguator_action
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if use_default_dedupe_for_error is not None:
            self._values["use_default_dedupe_for_error"] = use_default_dedupe_for_error
        if use_default_dedupe_for_latency is not None:
            self._values["use_default_dedupe_for_latency"] = use_default_dedupe_for_latency

    @builtins.property
    def actions_enabled(
        self,
    ) -> typing.Union[builtins.bool, typing.Mapping[builtins.str, builtins.bool]]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions for either all severities, or per severity.

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        assert result is not None, "Required property 'actions_enabled' is missing"
        return typing.cast(typing.Union[builtins.bool, typing.Mapping[builtins.str, builtins.bool]], result)

    @builtins.property
    def alarm_name_prefix(self) -> builtins.str:
        '''(experimental) Global prefix for all alarm names.

        This should be something unique to avoid potential collisions.
        This is ignored if an alarm's dedupeStringOverride is declared.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_prefix")
        assert result is not None, "Required property 'alarm_name_prefix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def action(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Default alarm action used for each alarm, unless it is overridden.

        :default: - no action.

        :stability: experimental
        '''
        result = self._values.get("action")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def alarm_naming_strategy(self) -> typing.Optional["IAlarmNamingStrategy"]:
        '''(experimental) Custom strategy to name alarms.

        :default: - default behaviour (no change)

        :stability: experimental
        '''
        result = self._values.get("alarm_naming_strategy")
        return typing.cast(typing.Optional["IAlarmNamingStrategy"], result)

    @builtins.property
    def annotation_strategy(self) -> typing.Optional["IAlarmAnnotationStrategy"]:
        '''(experimental) Custom strategy to create annotations for alarms.

        :default: - default annotations

        :stability: experimental
        '''
        result = self._values.get("annotation_strategy")
        return typing.cast(typing.Optional["IAlarmAnnotationStrategy"], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - 3

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_processor(self) -> typing.Optional["IAlarmDedupeStringProcessor"]:
        '''(experimental) Custom strategy to process dedupe strings of the alarms.

        :default: - default behaviour (no change)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_processor")
        return typing.cast(typing.Optional["IAlarmDedupeStringProcessor"], result)

    @builtins.property
    def disambiguator_action(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "IAlarmActionStrategy"]]:
        '''(experimental) Optional alarm action for each disambiguator.

        :default: - Global alarm action if defined.

        :stability: experimental
        '''
        result = self._values.get("disambiguator_action")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "IAlarmActionStrategy"]], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - Same as datapointsToAlarm.

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def use_default_dedupe_for_error(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If this is defined as false and dedupeStringOverride is undefined, the alarm prefix will be part of the dedupe string.

        This essentially stops the dedupe of different errors together.

        :default: - undefined (true)

        :stability: experimental
        '''
        result = self._values.get("use_default_dedupe_for_error")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_default_dedupe_for_latency(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If this is defined as false and dedupeStringOverride is undefined, the alarm prefix will be part of the dedupe string.

        This essentially stops the dedupe of different latency issues together.

        :default: - undefined (true)

        :stability: experimental
        '''
        result = self._values.get("use_default_dedupe_for_latency")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmFactoryDefaults(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmFactoryProps",
    jsii_struct_bases=[],
    name_mapping={
        "global_alarm_defaults": "globalAlarmDefaults",
        "global_metric_defaults": "globalMetricDefaults",
        "local_alarm_name_prefix": "localAlarmNamePrefix",
    },
)
class AlarmFactoryProps:
    def __init__(
        self,
        *,
        global_alarm_defaults: typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]],
        global_metric_defaults: typing.Union["MetricFactoryDefaults", typing.Dict[builtins.str, typing.Any]],
        local_alarm_name_prefix: builtins.str,
    ) -> None:
        '''
        :param global_alarm_defaults: 
        :param global_metric_defaults: 
        :param local_alarm_name_prefix: 

        :stability: experimental
        '''
        if isinstance(global_alarm_defaults, dict):
            global_alarm_defaults = AlarmFactoryDefaults(**global_alarm_defaults)
        if isinstance(global_metric_defaults, dict):
            global_metric_defaults = MetricFactoryDefaults(**global_metric_defaults)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c869e88286e2dfc35509526ef862e0cfb4c42a0649e4c63bd665753222cb46e6)
            check_type(argname="argument global_alarm_defaults", value=global_alarm_defaults, expected_type=type_hints["global_alarm_defaults"])
            check_type(argname="argument global_metric_defaults", value=global_metric_defaults, expected_type=type_hints["global_metric_defaults"])
            check_type(argname="argument local_alarm_name_prefix", value=local_alarm_name_prefix, expected_type=type_hints["local_alarm_name_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "global_alarm_defaults": global_alarm_defaults,
            "global_metric_defaults": global_metric_defaults,
            "local_alarm_name_prefix": local_alarm_name_prefix,
        }

    @builtins.property
    def global_alarm_defaults(self) -> AlarmFactoryDefaults:
        '''
        :stability: experimental
        '''
        result = self._values.get("global_alarm_defaults")
        assert result is not None, "Required property 'global_alarm_defaults' is missing"
        return typing.cast(AlarmFactoryDefaults, result)

    @builtins.property
    def global_metric_defaults(self) -> "MetricFactoryDefaults":
        '''
        :stability: experimental
        '''
        result = self._values.get("global_metric_defaults")
        assert result is not None, "Required property 'global_metric_defaults' is missing"
        return typing.cast("MetricFactoryDefaults", result)

    @builtins.property
    def local_alarm_name_prefix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix")
        assert result is not None, "Required property 'local_alarm_name_prefix' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AlarmMatrixWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.AlarmStatusWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AlarmMatrixWidget",
):
    '''(experimental) Wrapper of Alarm Status Widget which auto-calcultes height based on the number of alarms.

    Always takes the maximum width.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        alarms: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm],
        height: typing.Optional[jsii.Number] = None,
        title: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarms: (experimental) list of alarms to show.
        :param height: (experimental) desired height. Default: - auto calculated based on alarm number (3 to 8)
        :param title: (experimental) widget title. Default: - no title

        :stability: experimental
        '''
        props = AlarmMatrixWidgetProps(alarms=alarms, height=height, title=title)

        jsii.create(self.__class__, self, [props])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmMatrixWidgetProps",
    jsii_struct_bases=[],
    name_mapping={"alarms": "alarms", "height": "height", "title": "title"},
)
class AlarmMatrixWidgetProps:
    def __init__(
        self,
        *,
        alarms: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm],
        height: typing.Optional[jsii.Number] = None,
        title: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarms: (experimental) list of alarms to show.
        :param height: (experimental) desired height. Default: - auto calculated based on alarm number (3 to 8)
        :param title: (experimental) widget title. Default: - no title

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__463435460989aaf64b7692dedebe0b8d2b0c80581d3c3d07eb2c1eecd4e34381)
            check_type(argname="argument alarms", value=alarms, expected_type=type_hints["alarms"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarms": alarms,
        }
        if height is not None:
            self._values["height"] = height
        if title is not None:
            self._values["title"] = title

    @builtins.property
    def alarms(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm]:
        '''(experimental) list of alarms to show.

        :stability: experimental
        '''
        result = self._values.get("alarms")
        assert result is not None, "Required property 'alarms' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm], result)

    @builtins.property
    def height(self) -> typing.Optional[jsii.Number]:
        '''(experimental) desired height.

        :default: - auto calculated based on alarm number (3 to 8)

        :stability: experimental
        '''
        result = self._values.get("height")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''(experimental) widget title.

        :default: - no title

        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmMatrixWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmMetadata",
    jsii_struct_bases=[],
    name_mapping={
        "action": "action",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "dedupe_string": "dedupeString",
        "disambiguator": "disambiguator",
    },
)
class AlarmMetadata:
    def __init__(
        self,
        *,
        action: "IAlarmActionStrategy",
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Metadata of an alarm.

        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a288f9cbedc2527a99cfdce02b50d304eb7ca87e1f84770b7ca0ab2936166d03)
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "action": action,
        }
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if dedupe_string is not None:
            self._values["dedupe_string"] = dedupe_string
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator

    @builtins.property
    def action(self) -> "IAlarmActionStrategy":
        '''
        :stability: experimental
        '''
        result = self._values.get("action")
        assert result is not None, "Required property 'action' is missing"
        return typing.cast("IAlarmActionStrategy", result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def dedupe_string(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmMetadata(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmNamingInput",
    jsii_struct_bases=[],
    name_mapping={
        "alarm_name_suffix": "alarmNameSuffix",
        "alarm_dedupe_string_suffix": "alarmDedupeStringSuffix",
        "alarm_name_override": "alarmNameOverride",
        "dedupe_string_override": "dedupeStringOverride",
        "disambiguator": "disambiguator",
    },
)
class AlarmNamingInput:
    def __init__(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d25bb5967177f38d05439f611826798ffb0b415e4c23ed717c4b6dc280ee9de1)
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument alarm_dedupe_string_suffix", value=alarm_dedupe_string_suffix, expected_type=type_hints["alarm_dedupe_string_suffix"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_name_suffix": alarm_name_suffix,
        }
        if alarm_dedupe_string_suffix is not None:
            self._values["alarm_dedupe_string_suffix"] = alarm_dedupe_string_suffix
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator

    @builtins.property
    def alarm_name_suffix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_name_suffix")
        assert result is not None, "Required property 'alarm_name_suffix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_dedupe_string_suffix(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_dedupe_string_suffix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmNamingInput(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AlarmSummaryMatrixWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.ConcreteWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AlarmSummaryMatrixWidget",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        alarm_arns: typing.Sequence[builtins.str],
        height: typing.Optional[jsii.Number] = None,
        region: typing.Optional[builtins.str] = None,
        title: typing.Optional[builtins.str] = None,
        width: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param alarm_arns: 
        :param height: Height of the widget. Default: - 6 for Alarm and Graph widgets. 3 for single value widgets where most recent value of a metric is displayed.
        :param region: The region the metrics of this graph should be taken from. Default: - Current region
        :param title: Title for the graph. Default: - None
        :param width: Width of the widget, in a grid of 24 units wide. Default: 6

        :stability: experimental
        '''
        props = AlarmSummaryMatrixWidgetProps(
            alarm_arns=alarm_arns,
            height=height,
            region=region,
            title=title,
            width=width,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="toJson")
    def to_json(self) -> typing.List[typing.Any]:
        '''(experimental) Return the widget JSON for use in the dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Any], jsii.invoke(self, "toJson", []))

    @builtins.property
    @jsii.member(jsii_name="props")
    def _props(self) -> "AlarmSummaryMatrixWidgetProps":
        '''
        :stability: experimental
        '''
        return typing.cast("AlarmSummaryMatrixWidgetProps", jsii.get(self, "props"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmSummaryMatrixWidgetPropertiesJson",
    jsii_struct_bases=[],
    name_mapping={"alarms": "alarms", "title": "title"},
)
class AlarmSummaryMatrixWidgetPropertiesJson:
    def __init__(
        self,
        *,
        alarms: typing.Sequence[builtins.str],
        title: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarms: 
        :param title: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__47462653cba6d57de993c3c3c9ba4374cd78d9cc6f6789e80053f076539808bb)
            check_type(argname="argument alarms", value=alarms, expected_type=type_hints["alarms"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarms": alarms,
        }
        if title is not None:
            self._values["title"] = title

    @builtins.property
    def alarms(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarms")
        assert result is not None, "Required property 'alarms' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmSummaryMatrixWidgetPropertiesJson(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmSummaryMatrixWidgetProps",
    jsii_struct_bases=[_aws_cdk_aws_cloudwatch_ceddda9d.MetricWidgetProps],
    name_mapping={
        "height": "height",
        "region": "region",
        "title": "title",
        "width": "width",
        "alarm_arns": "alarmArns",
    },
)
class AlarmSummaryMatrixWidgetProps(_aws_cdk_aws_cloudwatch_ceddda9d.MetricWidgetProps):
    def __init__(
        self,
        *,
        height: typing.Optional[jsii.Number] = None,
        region: typing.Optional[builtins.str] = None,
        title: typing.Optional[builtins.str] = None,
        width: typing.Optional[jsii.Number] = None,
        alarm_arns: typing.Sequence[builtins.str],
    ) -> None:
        '''
        :param height: Height of the widget. Default: - 6 for Alarm and Graph widgets. 3 for single value widgets where most recent value of a metric is displayed.
        :param region: The region the metrics of this graph should be taken from. Default: - Current region
        :param title: Title for the graph. Default: - None
        :param width: Width of the widget, in a grid of 24 units wide. Default: 6
        :param alarm_arns: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f2355c8da2ac06f8dd3b82e21a273b452d42e2a6ecbcd9436edf48426384acb)
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument alarm_arns", value=alarm_arns, expected_type=type_hints["alarm_arns"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_arns": alarm_arns,
        }
        if height is not None:
            self._values["height"] = height
        if region is not None:
            self._values["region"] = region
        if title is not None:
            self._values["title"] = title
        if width is not None:
            self._values["width"] = width

    @builtins.property
    def height(self) -> typing.Optional[jsii.Number]:
        '''Height of the widget.

        :default:

        - 6 for Alarm and Graph widgets.
        3 for single value widgets where most recent value of a metric is displayed.
        '''
        result = self._values.get("height")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''The region the metrics of this graph should be taken from.

        :default: - Current region
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''Title for the graph.

        :default: - None
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def width(self) -> typing.Optional[jsii.Number]:
        '''Width of the widget, in a grid of 24 units wide.

        :default: 6
        '''
        result = self._values.get("width")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def alarm_arns(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_arns")
        assert result is not None, "Required property 'alarm_arns' is missing"
        return typing.cast(typing.List[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmSummaryMatrixWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmWithAnnotation",
    jsii_struct_bases=[AlarmMetadata],
    name_mapping={
        "action": "action",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "dedupe_string": "dedupeString",
        "disambiguator": "disambiguator",
        "alarm": "alarm",
        "alarm_description": "alarmDescription",
        "alarm_label": "alarmLabel",
        "alarm_name": "alarmName",
        "alarm_name_suffix": "alarmNameSuffix",
        "alarm_rule_when_alarming": "alarmRuleWhenAlarming",
        "alarm_rule_when_insufficient_data": "alarmRuleWhenInsufficientData",
        "alarm_rule_when_ok": "alarmRuleWhenOk",
        "annotation": "annotation",
    },
)
class AlarmWithAnnotation(AlarmMetadata):
    def __init__(
        self,
        *,
        action: "IAlarmActionStrategy",
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        alarm_description: builtins.str,
        alarm_label: builtins.str,
        alarm_name: builtins.str,
        alarm_name_suffix: builtins.str,
        alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
    ) -> None:
        '''(experimental) Representation of an alarm with additional information.

        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 
        :param alarm: 
        :param alarm_description: 
        :param alarm_label: 
        :param alarm_name: 
        :param alarm_name_suffix: 
        :param alarm_rule_when_alarming: 
        :param alarm_rule_when_insufficient_data: 
        :param alarm_rule_when_ok: 
        :param annotation: 

        :stability: experimental
        '''
        if isinstance(annotation, dict):
            annotation = _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation(**annotation)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8606c0117095ab9f7dc09c615dcfe6943276093179ddf454ed85256c77bb9047)
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument alarm", value=alarm, expected_type=type_hints["alarm"])
            check_type(argname="argument alarm_description", value=alarm_description, expected_type=type_hints["alarm_description"])
            check_type(argname="argument alarm_label", value=alarm_label, expected_type=type_hints["alarm_label"])
            check_type(argname="argument alarm_name", value=alarm_name, expected_type=type_hints["alarm_name"])
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument alarm_rule_when_alarming", value=alarm_rule_when_alarming, expected_type=type_hints["alarm_rule_when_alarming"])
            check_type(argname="argument alarm_rule_when_insufficient_data", value=alarm_rule_when_insufficient_data, expected_type=type_hints["alarm_rule_when_insufficient_data"])
            check_type(argname="argument alarm_rule_when_ok", value=alarm_rule_when_ok, expected_type=type_hints["alarm_rule_when_ok"])
            check_type(argname="argument annotation", value=annotation, expected_type=type_hints["annotation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "action": action,
            "alarm": alarm,
            "alarm_description": alarm_description,
            "alarm_label": alarm_label,
            "alarm_name": alarm_name,
            "alarm_name_suffix": alarm_name_suffix,
            "alarm_rule_when_alarming": alarm_rule_when_alarming,
            "alarm_rule_when_insufficient_data": alarm_rule_when_insufficient_data,
            "alarm_rule_when_ok": alarm_rule_when_ok,
            "annotation": annotation,
        }
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if dedupe_string is not None:
            self._values["dedupe_string"] = dedupe_string
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator

    @builtins.property
    def action(self) -> "IAlarmActionStrategy":
        '''
        :stability: experimental
        '''
        result = self._values.get("action")
        assert result is not None, "Required property 'action' is missing"
        return typing.cast("IAlarmActionStrategy", result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def dedupe_string(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm")
        assert result is not None, "Required property 'alarm' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase, result)

    @builtins.property
    def alarm_description(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_description")
        assert result is not None, "Required property 'alarm_description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_label(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_label")
        assert result is not None, "Required property 'alarm_label' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_name")
        assert result is not None, "Required property 'alarm_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_name_suffix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_name_suffix")
        assert result is not None, "Required property 'alarm_name_suffix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_rule_when_alarming(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_rule_when_alarming")
        assert result is not None, "Required property 'alarm_rule_when_alarming' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule, result)

    @builtins.property
    def alarm_rule_when_insufficient_data(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_rule_when_insufficient_data")
        assert result is not None, "Required property 'alarm_rule_when_insufficient_data' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule, result)

    @builtins.property
    def alarm_rule_when_ok(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_rule_when_ok")
        assert result is not None, "Required property 'alarm_rule_when_ok' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule, result)

    @builtins.property
    def annotation(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''
        :stability: experimental
        '''
        result = self._values.get("annotation")
        assert result is not None, "Required property 'annotation' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmWithAnnotation(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AnomalyDetectingAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AnomalyDetectingAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca1dd234346f02605e07e5918b0374facbff98d61247fd2587d6f1ff699e2280)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addAlarmWhenOutOfBand")
    def add_alarm_when_out_of_band(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_name_suffix: builtins.str,
        disambiguator: builtins.str,
        *,
        alarm_when_above_the_band: builtins.bool,
        alarm_when_below_the_band: builtins.bool,
        standard_deviation_for_alarm: jsii.Number,
        additional_description: typing.Optional[builtins.str] = None,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param alarm_name_suffix: -
        :param disambiguator: -
        :param alarm_when_above_the_band: 
        :param alarm_when_below_the_band: 
        :param standard_deviation_for_alarm: 
        :param additional_description: 
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d863399e1672ef027989f01638846f5a0a3cc8029ea4e58174909946a6add25)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        props = AnomalyDetectionThreshold(
            alarm_when_above_the_band=alarm_when_above_the_band,
            alarm_when_below_the_band=alarm_when_below_the_band,
            standard_deviation_for_alarm=standard_deviation_for_alarm,
            additional_description=additional_description,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            comparison_operator_override=comparison_operator_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
            treat_missing_data_override=treat_missing_data_override,
        )

        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addAlarmWhenOutOfBand", [metric, alarm_name_suffix, disambiguator, props]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class AnomalyDetectionMathExpression(
    _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AnomalyDetectionMathExpression",
):
    '''(experimental) Captures specific MathExpression for anomaly detection, for which alarm generation is different.

    Added to overcome certain CDK limitations at the time of writing.

    :see: https://github.com/aws/aws-cdk/issues/10540
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        expression: builtins.str,
        using_metrics: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]] = None,
        color: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        search_account: typing.Optional[builtins.str] = None,
        search_region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param expression: The expression defining the metric. When an expression contains a SEARCH function, it cannot be used within an Alarm.
        :param using_metrics: The metrics used in the expression, in a map. The key is the identifier that represents the given metric in the expression, and the value is the actual Metric object. Default: - Empty map.
        :param color: Color for this metric when added to a Graph in a Dashboard. Default: - Automatic color
        :param label: Label for this expression when added to a Graph in a Dashboard. If this expression evaluates to more than one time series (for example, through the use of ``METRICS()`` or ``SEARCH()`` expressions), each time series will appear in the graph using a combination of the expression label and the individual metric label. Specify the empty string (``''``) to suppress the expression label and only keep the metric label. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. If the math expression produces more than one time series, the maximum will be shown for each individual time series produce by this math expression. Default: - Expression value is used as label
        :param period: The period over which the expression's statistics are applied. This period overrides all periods in the metrics used in this math expression. Default: Duration.minutes(5)
        :param search_account: Account to evaluate search expressions within. Specifying a searchAccount has no effect to the account used for metrics within the expression (passed via usingMetrics). Default: - Deployment account.
        :param search_region: Region to evaluate search expressions within. Specifying a searchRegion has no effect to the region used for metrics within the expression (passed via usingMetrics). Default: - Deployment region.

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MathExpressionProps(
            expression=expression,
            using_metrics=using_metrics,
            color=color,
            label=label,
            period=period,
            search_account=search_account,
            search_region=search_region,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="createAlarm")
    def create_alarm(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        evaluation_periods: jsii.Number,
        threshold: jsii.Number,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_name: typing.Optional[builtins.str] = None,
        comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.str] = None,
        treat_missing_data: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Alarm:
        '''(experimental) Make a new Alarm for this metric.

        Combines both properties that may adjust the metric (aggregation) as well
        as alarm properties.

        :param scope: -
        :param id: -
        :param evaluation_periods: The number of periods over which data is compared to the specified threshold.
        :param threshold: The value against which the specified statistic is compared.
        :param actions_enabled: Whether the actions for this alarm are enabled. Default: true
        :param alarm_description: Description for the alarm. Default: No description
        :param alarm_name: Name of the alarm. Default: Automatically generated name
        :param comparison_operator: Comparison to use to check if metric is breaching. Default: GreaterThanOrEqualToThreshold
        :param datapoints_to_alarm: The number of datapoints that must be breaching to trigger the alarm. This is used only if you are setting an "M out of N" alarm. In that case, this value is the M. For more information, see Evaluating an Alarm in the Amazon CloudWatch User Guide. Default: ``evaluationPeriods``
        :param evaluate_low_sample_count_percentile: Specifies whether to evaluate the data and potentially change the alarm state if there are too few data points to be statistically significant. Used only for alarms that are based on percentiles. Default: - Not configured.
        :param treat_missing_data: Sets how this alarm is to handle missing data points. Default: TreatMissingData.Missing

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c267e31c8cd5c1bd0e3b8ff667c6a95c1fdea3d6830e885260dc17f2e9cb7176)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.CreateAlarmOptions(
            evaluation_periods=evaluation_periods,
            threshold=threshold,
            actions_enabled=actions_enabled,
            alarm_description=alarm_description,
            alarm_name=alarm_name,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            treat_missing_data=treat_missing_data,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Alarm, jsii.invoke(self, "createAlarm", [scope, id, props]))

    @jsii.member(jsii_name="with")
    def with_(
        self,
        *,
        color: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        search_account: typing.Optional[builtins.str] = None,
        search_region: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression:
        '''(experimental) Return a copy of Metric with properties changed.

        All properties except namespace and metricName can be changed.

        :param color: Color for this metric when added to a Graph in a Dashboard. Default: - Automatic color
        :param label: Label for this expression when added to a Graph in a Dashboard. If this expression evaluates to more than one time series (for example, through the use of ``METRICS()`` or ``SEARCH()`` expressions), each time series will appear in the graph using a combination of the expression label and the individual metric label. Specify the empty string (``''``) to suppress the expression label and only keep the metric label. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. If the math expression produces more than one time series, the maximum will be shown for each individual time series produce by this math expression. Default: - Expression value is used as label
        :param period: The period over which the expression's statistics are applied. This period overrides all periods in the metrics used in this math expression. Default: Duration.minutes(5)
        :param search_account: Account to evaluate search expressions within. Specifying a searchAccount has no effect to the account used for metrics within the expression (passed via usingMetrics). Default: - Deployment account.
        :param search_region: Region to evaluate search expressions within. Specifying a searchRegion has no effect to the region used for metrics within the expression (passed via usingMetrics). Default: - Deployment region.

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MathExpressionOptions(
            color=color,
            label=label,
            period=period,
            search_account=search_account,
            search_region=search_region,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, jsii.invoke(self, "with", [props]))


class AuroraAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AuroraAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45099e6670c87a932c599eed1c0ba693bc08493523432b141bc6248da9d66b3b)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxServerlessDatabaseCapacity")
    def add_max_serverless_database_capacity(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["HighServerlessDatabaseCapacityThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b71ef0b811f575d598fdc0bfa08f194d6c45d1a3f0a8c673c1b44803af6830c3)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxServerlessDatabaseCapacity", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class AwsConsoleUrlFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AwsConsoleUrlFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        aws_account_id: builtins.str,
        aws_account_region: builtins.str,
    ) -> None:
        '''
        :param aws_account_id: 
        :param aws_account_region: 

        :stability: experimental
        '''
        props = AwsConsoleUrlFactoryProps(
            aws_account_id=aws_account_id, aws_account_region=aws_account_region
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="getApiGatewayUrl")
    def get_api_gateway_url(
        self,
        rest_api_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param rest_api_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a302367485dea2f83d283bbffd3a30fcb95f40c4aab9c2fc59ae45bc5c3bee2)
            check_type(argname="argument rest_api_id", value=rest_api_id, expected_type=type_hints["rest_api_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getApiGatewayUrl", [rest_api_id]))

    @jsii.member(jsii_name="getAwsConsoleUrl")
    def get_aws_console_url(
        self,
        destination_url: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[builtins.str]:
        '''
        :param destination_url: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9fa931f716446770b6198d959d612e3e1f62b9535416b38c81f376bc96b406a)
            check_type(argname="argument destination_url", value=destination_url, expected_type=type_hints["destination_url"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getAwsConsoleUrl", [destination_url]))

    @jsii.member(jsii_name="getCloudFrontDistributionUrl")
    def get_cloud_front_distribution_url(
        self,
        distribution_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param distribution_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d2fc341bda8f3937b986f45b4004713a1a325e885243d595bf5dc36ac086579)
            check_type(argname="argument distribution_id", value=distribution_id, expected_type=type_hints["distribution_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getCloudFrontDistributionUrl", [distribution_id]))

    @jsii.member(jsii_name="getCloudWatchLogGroupUrl")
    def get_cloud_watch_log_group_url(
        self,
        log_group_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param log_group_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ccbdab9ee8ad9cd94af10d8759710d20f8ec418a5aa43f570d63704ed363e51)
            check_type(argname="argument log_group_name", value=log_group_name, expected_type=type_hints["log_group_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getCloudWatchLogGroupUrl", [log_group_name]))

    @jsii.member(jsii_name="getCodeBuildProjectUrl")
    def get_code_build_project_url(
        self,
        project_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param project_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1721206924f1d4352cf8b628a428534fea6e7d4f148379e822a4eccc1476f21e)
            check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getCodeBuildProjectUrl", [project_name]))

    @jsii.member(jsii_name="getDocumentDbClusterUrl")
    def get_document_db_cluster_url(
        self,
        cluster_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param cluster_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9ab81f8eaf1a584f8044af6409095e094493e7ea72f8334d6d73ce8bbf245f9)
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getDocumentDbClusterUrl", [cluster_id]))

    @jsii.member(jsii_name="getDynamoTableUrl")
    def get_dynamo_table_url(
        self,
        table_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param table_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__517d326fd9bec70b977d583a7e8fbcdda18affe19817256e3006e7c72a5ec17e)
            check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getDynamoTableUrl", [table_name]))

    @jsii.member(jsii_name="getElastiCacheClusterUrl")
    def get_elasti_cache_cluster_url(
        self,
        cluster_id: builtins.str,
        cluster_type: "ElastiCacheClusterType",
    ) -> typing.Optional[builtins.str]:
        '''
        :param cluster_id: -
        :param cluster_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d14f1c234d8fcbd3c9f838e3a0bbc944d0fb0e37ecb635c0556fd2e8ed4550d9)
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
            check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getElastiCacheClusterUrl", [cluster_id, cluster_type]))

    @jsii.member(jsii_name="getKinesisAnalyticsUrl")
    def get_kinesis_analytics_url(
        self,
        application: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param application: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51bfd6615794af62e068fcf0162174cc3c655c65dd4ada1851257e8591cfa0d0)
            check_type(argname="argument application", value=application, expected_type=type_hints["application"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getKinesisAnalyticsUrl", [application]))

    @jsii.member(jsii_name="getKinesisDataStreamUrl")
    def get_kinesis_data_stream_url(
        self,
        stream_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param stream_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b052496cd95fd34ebd8344edaf2425648e45ff739a363f89edde8b084c427135)
            check_type(argname="argument stream_name", value=stream_name, expected_type=type_hints["stream_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getKinesisDataStreamUrl", [stream_name]))

    @jsii.member(jsii_name="getKinesisFirehoseDeliveryStreamUrl")
    def get_kinesis_firehose_delivery_stream_url(
        self,
        stream_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param stream_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f800b688b83a46e9337c3a5cf2d0f188d99cf0b4cbce5d4c5def309d19898450)
            check_type(argname="argument stream_name", value=stream_name, expected_type=type_hints["stream_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getKinesisFirehoseDeliveryStreamUrl", [stream_name]))

    @jsii.member(jsii_name="getLambdaFunctionUrl")
    def get_lambda_function_url(
        self,
        function_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param function_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__26577adb183f727fe17f3acfe2f1dc664554523a62ab72d895cdbe83ba547680)
            check_type(argname="argument function_name", value=function_name, expected_type=type_hints["function_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getLambdaFunctionUrl", [function_name]))

    @jsii.member(jsii_name="getOpenSearchClusterUrl")
    def get_open_search_cluster_url(
        self,
        domain_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param domain_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__91f4dae5dfbeff2df56e88918e374bcfefe4e73b54ce769c16ed71a1b74bf13a)
            check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getOpenSearchClusterUrl", [domain_name]))

    @jsii.member(jsii_name="getRdsClusterUrl")
    def get_rds_cluster_url(
        self,
        cluster_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param cluster_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc3c719907418142a6760e6679e5abd7ac2fce675800dee9dbb5a8cef07f051c)
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getRdsClusterUrl", [cluster_id]))

    @jsii.member(jsii_name="getRdsInstanceUrl")
    def get_rds_instance_url(
        self,
        instance_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param instance_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__09cebd1b1aa6a2b2e8eef50543b5ecc8686b3929e0cb6d45d7f1c048b92227d6)
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getRdsInstanceUrl", [instance_id]))

    @jsii.member(jsii_name="getRedshiftClusterUrl")
    def get_redshift_cluster_url(
        self,
        cluster_id: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param cluster_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5eb33a5fec989cd265956e305af30c9ca8d089e8fa6dde6a824a3e5c1b4b5a0b)
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getRedshiftClusterUrl", [cluster_id]))

    @jsii.member(jsii_name="getResolvedDestinationUrl")
    def _get_resolved_destination_url(
        self,
        context: _aws_cdk_ceddda9d.IResolveContext,
        destination_url: builtins.str,
    ) -> builtins.str:
        '''(experimental) Resolves a destination URL within a resolution context.

        :param context: The resolution context.
        :param destination_url: The destination URL to resolve since it may contain CDK tokens.

        :see: https://docs.aws.amazon.com/cdk/latest/guide/tokens.html
        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d66ed73316f4263813d06b35e95be33d7add9f32c7f66eab4789bb7dc497cdd8)
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument destination_url", value=destination_url, expected_type=type_hints["destination_url"])
        return typing.cast(builtins.str, jsii.invoke(self, "getResolvedDestinationUrl", [context, destination_url]))

    @jsii.member(jsii_name="getS3BucketUrl")
    def get_s3_bucket_url(
        self,
        bucket_name: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param bucket_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57a7a331c5bc38c2efa83af3acf5aadc8f0e1f31a8acc4bef61ff5bd97835ed9)
            check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getS3BucketUrl", [bucket_name]))

    @jsii.member(jsii_name="getSnsTopicUrl")
    def get_sns_topic_url(
        self,
        topic_arn: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param topic_arn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f053198c3999248b019ef20efca56a15fb7d9a7545a611e7367808f4c7056510)
            check_type(argname="argument topic_arn", value=topic_arn, expected_type=type_hints["topic_arn"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getSnsTopicUrl", [topic_arn]))

    @jsii.member(jsii_name="getSqsQueueUrl")
    def get_sqs_queue_url(
        self,
        queue_url: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param queue_url: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__acff584563d9cf4fcec3d3a8cfe679a51ae080d79e4d74fb083e56e0cb56591e)
            check_type(argname="argument queue_url", value=queue_url, expected_type=type_hints["queue_url"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getSqsQueueUrl", [queue_url]))

    @jsii.member(jsii_name="getStateMachineUrl")
    def get_state_machine_url(
        self,
        state_machine_arn: builtins.str,
    ) -> typing.Optional[builtins.str]:
        '''
        :param state_machine_arn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f73d101afd1bcf37923090d1ab5aca645a37de07af1ea5d4c6ecdad526b6a0fa)
            check_type(argname="argument state_machine_arn", value=state_machine_arn, expected_type=type_hints["state_machine_arn"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getStateMachineUrl", [state_machine_arn]))

    @builtins.property
    @jsii.member(jsii_name="awsAccountId")
    def _aws_account_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "awsAccountId"))

    @builtins.property
    @jsii.member(jsii_name="awsAccountRegion")
    def _aws_account_region(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "awsAccountRegion"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AwsConsoleUrlFactoryProps",
    jsii_struct_bases=[],
    name_mapping={
        "aws_account_id": "awsAccountId",
        "aws_account_region": "awsAccountRegion",
    },
)
class AwsConsoleUrlFactoryProps:
    def __init__(
        self,
        *,
        aws_account_id: builtins.str,
        aws_account_region: builtins.str,
    ) -> None:
        '''
        :param aws_account_id: 
        :param aws_account_region: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__01d030f40a3e16e59f7cf96acd793162b9493d52c448708f2eeb5f27856ffb12)
            check_type(argname="argument aws_account_id", value=aws_account_id, expected_type=type_hints["aws_account_id"])
            check_type(argname="argument aws_account_region", value=aws_account_region, expected_type=type_hints["aws_account_region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "aws_account_id": aws_account_id,
            "aws_account_region": aws_account_region,
        }

    @builtins.property
    def aws_account_id(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("aws_account_id")
        assert result is not None, "Required property 'aws_account_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def aws_account_region(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("aws_account_region")
        assert result is not None, "Required property 'aws_account_region' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AwsConsoleUrlFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.AxisPosition")
class AxisPosition(enum.Enum):
    '''
    :stability: experimental
    '''

    LEFT = "LEFT"
    '''
    :stability: experimental
    '''
    RIGHT = "RIGHT"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseDlqAlarms",
    jsii_struct_bases=[],
    name_mapping={
        "add_dead_letter_queue_max_incoming_messages_alarm": "addDeadLetterQueueMaxIncomingMessagesAlarm",
        "add_dead_letter_queue_max_message_age_alarm": "addDeadLetterQueueMaxMessageAgeAlarm",
        "add_dead_letter_queue_max_size_alarm": "addDeadLetterQueueMaxSizeAlarm",
    },
)
class BaseDlqAlarms:
    def __init__(
        self,
        *,
        add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxIncomingMessagesCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxMessageAgeThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxMessageCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param add_dead_letter_queue_max_incoming_messages_alarm: (experimental) Alarm on the number of messages added to a queue. Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ as a result of a failed processing attempt.
        :param add_dead_letter_queue_max_message_age_alarm: 
        :param add_dead_letter_queue_max_size_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19230e48c8ff23ffdbc393eaf7cc2cbb30370671bec7380cf3f4038e545692a9)
            check_type(argname="argument add_dead_letter_queue_max_incoming_messages_alarm", value=add_dead_letter_queue_max_incoming_messages_alarm, expected_type=type_hints["add_dead_letter_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_dead_letter_queue_max_message_age_alarm", value=add_dead_letter_queue_max_message_age_alarm, expected_type=type_hints["add_dead_letter_queue_max_message_age_alarm"])
            check_type(argname="argument add_dead_letter_queue_max_size_alarm", value=add_dead_letter_queue_max_size_alarm, expected_type=type_hints["add_dead_letter_queue_max_size_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_dead_letter_queue_max_incoming_messages_alarm is not None:
            self._values["add_dead_letter_queue_max_incoming_messages_alarm"] = add_dead_letter_queue_max_incoming_messages_alarm
        if add_dead_letter_queue_max_message_age_alarm is not None:
            self._values["add_dead_letter_queue_max_message_age_alarm"] = add_dead_letter_queue_max_message_age_alarm
        if add_dead_letter_queue_max_size_alarm is not None:
            self._values["add_dead_letter_queue_max_size_alarm"] = add_dead_letter_queue_max_size_alarm

    @builtins.property
    def add_dead_letter_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxIncomingMessagesCountThreshold"]]:
        '''(experimental) Alarm on the number of messages added to a queue.

        Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ
        as a result of a failed processing attempt.

        :see: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html#sqs-dlq-number-of-messages
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxIncomingMessagesCountThreshold"]], result)

    @builtins.property
    def add_dead_letter_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxMessageAgeThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxMessageAgeThreshold"]], result)

    @builtins.property
    def add_dead_letter_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxMessageCountThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxMessageCountThreshold"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseDlqAlarms(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseEc2ServiceAlarms",
    jsii_struct_bases=[],
    name_mapping={
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
    },
)
class BaseEc2ServiceAlarms:
    def __init__(
        self,
        *,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["RunningTaskCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a374d2a14038e603b79e04b4726864a2ba272f673f6d649bbb043b631daec26)
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "RunningTaskCountThreshold"]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "RunningTaskCountThreshold"]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseEc2ServiceAlarms(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseFargateServiceAlarms",
    jsii_struct_bases=[],
    name_mapping={
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
    },
)
class BaseFargateServiceAlarms:
    def __init__(
        self,
        *,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["RunningTaskCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f50ae327b5e929f8c9e2af7139056c8e677547504adf6c776c2980f3ff8013de)
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "UsageThreshold"]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "RunningTaskCountThreshold"]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "RunningTaskCountThreshold"]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseFargateServiceAlarms(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseLoadBalancerMetricFactoryProps",
    jsii_struct_bases=[],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
    },
)
class BaseLoadBalancerMetricFactoryProps:
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Base of Monitoring props for load-balancer metric factories.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__93a1c712a97fed26164b9d1fb242034019fce862ca9c7faed6f8cd35a1028fe9)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseLoadBalancerMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BaseMetricFactory(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdk-monitoring-constructs.BaseMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b2d177ffa9b34b3a77f6fdf3c77be3cf2cd6412c94950cd261c8f7e295e2ede)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = BaseMetricFactoryProps(account=account, region=region)

        jsii.create(self.__class__, self, [metric_factory, props])

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def _metric_factory(self) -> "MetricFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("MetricFactory", jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="account")
    def _account(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "account"))

    @builtins.property
    @jsii.member(jsii_name="region")
    def _region(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "region"))


class _BaseMetricFactoryProxy(BaseMetricFactory):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, BaseMetricFactory).__jsii_proxy_class__ = lambda : _BaseMetricFactoryProxy


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseMetricFactoryProps",
    jsii_struct_bases=[],
    name_mapping={"account": "account", "region": "region"},
)
class BaseMetricFactoryProps:
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eeeb06047be2392f291d4ecc7070ca9898aac57cc808d2336cb9cdcabd5185a8)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BaseServiceMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.BaseServiceMetricFactory",
):
    '''(experimental) Metric factory for a base service (parent class for e.g. Fargate and EC2 services).

    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param service: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__724fa79970d80d56207f37e702ab8b4763e3ffdaa57a5d5657c383f807fa6aab)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = BaseServiceMetricFactoryProps(
            service=service, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricClusterCpuUtilisationInPercent")
    def metric_cluster_cpu_utilisation_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterCpuUtilisationInPercent", []))

    @jsii.member(jsii_name="metricClusterMemoryUtilisationInPercent")
    def metric_cluster_memory_utilisation_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterMemoryUtilisationInPercent", []))

    @jsii.member(jsii_name="metricEphemeralStorageReserved")
    def metric_ephemeral_storage_reserved(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricEphemeralStorageReserved", []))

    @jsii.member(jsii_name="metricEphemeralStorageUsageInPercent")
    def metric_ephemeral_storage_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricEphemeralStorageUsageInPercent", []))

    @jsii.member(jsii_name="metricEphemeralStorageUtilized")
    def metric_ephemeral_storage_utilized(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricEphemeralStorageUtilized", []))

    @jsii.member(jsii_name="metricRunningTaskCount")
    def metric_running_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRunningTaskCount", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="service")
    def _service(self) -> _aws_cdk_aws_ecs_ceddda9d.IBaseService:
        '''
        :deprecated: This isn't required by cdk-monitoring-constructs anymore; use your own reference.

        :stability: deprecated
        '''
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.IBaseService, jsii.get(self, "service"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseServiceMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "service": "service"},
)
class BaseServiceMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    ) -> None:
        '''(experimental) Props to create BaseServiceMetricFactory.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param service: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c1d711261770259d1a4936b895bde5a1a8be59ffd7b4ae5072aeeb7da1cf6de)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service": service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service(self) -> _aws_cdk_aws_ecs_ceddda9d.IBaseService:
        '''
        :stability: experimental
        '''
        result = self._values.get("service")
        assert result is not None, "Required property 'service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.IBaseService, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseServiceMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseSqsQueueAlarms",
    jsii_struct_bases=[],
    name_mapping={
        "add_queue_max_incoming_messages_alarm": "addQueueMaxIncomingMessagesAlarm",
        "add_queue_max_message_age_alarm": "addQueueMaxMessageAgeAlarm",
        "add_queue_max_size_alarm": "addQueueMaxSizeAlarm",
        "add_queue_max_time_to_drain_messages_alarm": "addQueueMaxTimeToDrainMessagesAlarm",
        "add_queue_min_incoming_messages_alarm": "addQueueMinIncomingMessagesAlarm",
        "add_queue_min_size_alarm": "addQueueMinSizeAlarm",
    },
)
class BaseSqsQueueAlarms:
    def __init__(
        self,
        *,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxIncomingMessagesCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxMessageAgeThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxMessageCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MaxTimeToDrainThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MinIncomingMessagesCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["MinMessageCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b777bafd865107e9ffeb5eb6f71437827d8cb2d8e1ac28cfae56c2581175fd5f)
            check_type(argname="argument add_queue_max_incoming_messages_alarm", value=add_queue_max_incoming_messages_alarm, expected_type=type_hints["add_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_queue_max_message_age_alarm", value=add_queue_max_message_age_alarm, expected_type=type_hints["add_queue_max_message_age_alarm"])
            check_type(argname="argument add_queue_max_size_alarm", value=add_queue_max_size_alarm, expected_type=type_hints["add_queue_max_size_alarm"])
            check_type(argname="argument add_queue_max_time_to_drain_messages_alarm", value=add_queue_max_time_to_drain_messages_alarm, expected_type=type_hints["add_queue_max_time_to_drain_messages_alarm"])
            check_type(argname="argument add_queue_min_incoming_messages_alarm", value=add_queue_min_incoming_messages_alarm, expected_type=type_hints["add_queue_min_incoming_messages_alarm"])
            check_type(argname="argument add_queue_min_size_alarm", value=add_queue_min_size_alarm, expected_type=type_hints["add_queue_min_size_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_queue_max_incoming_messages_alarm is not None:
            self._values["add_queue_max_incoming_messages_alarm"] = add_queue_max_incoming_messages_alarm
        if add_queue_max_message_age_alarm is not None:
            self._values["add_queue_max_message_age_alarm"] = add_queue_max_message_age_alarm
        if add_queue_max_size_alarm is not None:
            self._values["add_queue_max_size_alarm"] = add_queue_max_size_alarm
        if add_queue_max_time_to_drain_messages_alarm is not None:
            self._values["add_queue_max_time_to_drain_messages_alarm"] = add_queue_max_time_to_drain_messages_alarm
        if add_queue_min_incoming_messages_alarm is not None:
            self._values["add_queue_min_incoming_messages_alarm"] = add_queue_min_incoming_messages_alarm
        if add_queue_min_size_alarm is not None:
            self._values["add_queue_min_size_alarm"] = add_queue_min_size_alarm

    @builtins.property
    def add_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxIncomingMessagesCountThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxIncomingMessagesCountThreshold"]], result)

    @builtins.property
    def add_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxMessageAgeThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxMessageAgeThreshold"]], result)

    @builtins.property
    def add_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxMessageCountThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxMessageCountThreshold"]], result)

    @builtins.property
    def add_queue_max_time_to_drain_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MaxTimeToDrainThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_time_to_drain_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MaxTimeToDrainThreshold"]], result)

    @builtins.property
    def add_queue_min_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MinIncomingMessagesCountThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MinIncomingMessagesCountThreshold"]], result)

    @builtins.property
    def add_queue_min_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "MinMessageCountThreshold"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "MinMessageCountThreshold"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseSqsQueueAlarms(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BillingMetricFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.BillingMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="metricSearchTopCostByServiceInUsd")
    def metric_search_top_cost_by_service_in_usd(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IMetric:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric, jsii.invoke(self, "metricSearchTopCostByServiceInUsd", []))

    @jsii.member(jsii_name="metricTotalCostInUsd")
    def metric_total_cost_in_usd(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalCostInUsd", []))


class BitmapDashboard(
    _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.BitmapDashboard",
):
    '''(experimental) Specific subtype of dashboard that renders supported widgets as bitmaps, while preserving the overall layout.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        dashboard_name: typing.Optional[builtins.str] = None,
        default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        end: typing.Optional[builtins.str] = None,
        period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        start: typing.Optional[builtins.str] = None,
        variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
        widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param dashboard_name: Name of the dashboard. If set, must only contain alphanumerics, dash (-) and underscore (_) Default: - automatically generated name
        :param default_interval: Interval duration for metrics. You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)). Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the defaultInterval time will be the default time range.
        :param end: The end of the time range to use for each widget on the dashboard when the dashboard loads. If you specify a value for end, you must also specify a value for start. Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Default: When the dashboard loads, the end date will be the current time.
        :param period_override: Use this field to specify the period for the graphs when the dashboard loads. Specifying ``Auto`` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard. Specifying ``Inherit`` ensures that the period set for each graph is always obeyed. Default: Auto
        :param start: The start of the time range to use for each widget on the dashboard. You can specify start without specifying end to specify a relative time range that ends with the current time. In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months. You can also use start along with an end field, to specify an absolute time range. When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the start time will be the default time range.
        :param variables: A list of dashboard variables. Default: - No variables
        :param widgets: Initial set of widgets on the dashboard. One array represents a row of widgets. Default: - No widgets

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5c7742b8b54cb6637a8a37e189f49a77759cea15bcf58867b00f58b2202e86dd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.DashboardProps(
            dashboard_name=dashboard_name,
            default_interval=default_interval,
            end=end,
            period_override=period_override,
            start=start,
            variables=variables,
            widgets=widgets,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addWidgets")
    def add_widgets(self, *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget) -> None:
        '''(experimental) Add a widget to the dashboard.

        Widgets given in multiple calls to add() will be laid out stacked on
        top of each other.

        Multiple widgets added in the same call to add() will be laid out next
        to each other.

        :param widgets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b5470e02a552bb0f6e8dec61a319b082b25e94f192aef8457b0666311b05631)
            check_type(argname="argument widgets", value=widgets, expected_type=typing.Tuple[type_hints["widgets"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addWidgets", [*widgets]))

    @jsii.member(jsii_name="asBitmap")
    def _as_bitmap(
        self,
        widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IWidget:
        '''
        :param widget: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3663a57c2ca48fdc1f40cbf61227072b6790c447c88174fd56975128c585e23)
            check_type(argname="argument widget", value=widget, expected_type=type_hints["widget"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IWidget, jsii.invoke(self, "asBitmap", [widget]))

    @jsii.member(jsii_name="asBitmaps")
    def _as_bitmaps(
        self,
        *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''
        :param widgets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b19e10e301180ea922526542acd6aaf9262e183c51917124faf22d1f01d4c4f)
            check_type(argname="argument widgets", value=widgets, expected_type=typing.Tuple[type_hints["widgets"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "asBitmaps", [*widgets]))

    @builtins.property
    @jsii.member(jsii_name="bitmapRenderingSupport")
    def _bitmap_rendering_support(self) -> "BitmapWidgetRenderingSupport":
        '''
        :stability: experimental
        '''
        return typing.cast("BitmapWidgetRenderingSupport", jsii.get(self, "bitmapRenderingSupport"))


class BitmapWidgetRenderingSupport(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.BitmapWidgetRenderingSupport",
):
    '''(experimental) Support for rendering bitmap widgets on the server side.

    It is a custom widget lambda with some additional roles and helper methods.

    :stability: experimental
    '''

    def __init__(self, scope: _constructs_77d1e7e8.Construct, id: builtins.str) -> None:
        '''
        :param scope: -
        :param id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f271ada55f3c1300be52c5b0063d88118bede583cbf6759108eb757308467494)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        jsii.create(self.__class__, self, [scope, id])

    @jsii.member(jsii_name="asBitmap")
    def as_bitmap(
        self,
        widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    ) -> "CustomWidget":
        '''
        :param widget: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4226316e5fef6d2d87c15b71fb429fcf63e54ef78a81e473e27c86a202be1a0c)
            check_type(argname="argument widget", value=widget, expected_type=type_hints["widget"])
        return typing.cast("CustomWidget", jsii.invoke(self, "asBitmap", [widget]))

    @jsii.member(jsii_name="getWidgetProperties")
    def _get_widget_properties(
        self,
        widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    ) -> typing.Any:
        '''
        :param widget: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e1c6b21948df5c652d071f244ed6334fa28ee0399c526280faceef8f40ac20a)
            check_type(argname="argument widget", value=widget, expected_type=type_hints["widget"])
        return typing.cast(typing.Any, jsii.invoke(self, "getWidgetProperties", [widget]))

    @builtins.property
    @jsii.member(jsii_name="handler")
    def handler(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, jsii.get(self, "handler"))


@jsii.enum(jsii_type="cdk-monitoring-constructs.CapacityType")
class CapacityType(enum.Enum):
    '''
    :stability: experimental
    '''

    READ = "READ"
    '''
    :stability: experimental
    '''
    WRITE = "WRITE"
    '''
    :stability: experimental
    '''


class CertificateManagerMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CertificateManagerMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param certificate: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eab5a40604a68835b050f9b6ecc5f93e172e7f9bcb3f0139868546c26ccf9f19)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = CertificateManagerMetricFactoryProps(
            certificate=certificate, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricDaysToExpiry")
    def metric_days_to_expiry(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDaysToExpiry", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CertificateManagerMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "certificate": "certificate",
    },
)
class CertificateManagerMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param certificate: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8e364cfec12cd462f50660f97c3bf53e934bdb1a965de5f08b03d57e643715d1)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "certificate": certificate,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def certificate(self) -> _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate:
        '''
        :stability: experimental
        '''
        result = self._values.get("certificate")
        assert result is not None, "Required property 'certificate' is missing"
        return typing.cast(_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CertificateManagerMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CloudFrontDistributionMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CloudFrontDistributionMetricFactory",
):
    '''(experimental) To get the CloudFront metrics from the CloudWatch API, you must use the US East (N.

    Virginia) Region (us-east-1).
    https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/programming-cloudwatch-metrics.html

    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
        additional_metrics_enabled: typing.Optional[builtins.bool] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param distribution: 
        :param additional_metrics_enabled: (experimental) Generate dashboard charts for additional CloudFront distribution metrics. To enable additional metrics on your CloudFront distribution, see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional Default: - true
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51016d5aa3f742c63e4bd2330ab30b53e50b5404648f41485b81306c7bd53328)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = CloudFrontDistributionMetricFactoryProps(
            distribution=distribution,
            additional_metrics_enabled=additional_metrics_enabled,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metric4xxErrorRateAverage")
    def metric4xx_error_rate_average(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4xxErrorRateAverage", []))

    @jsii.member(jsii_name="metric5xxErrorRateAverage")
    def metric5xx_error_rate_average(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5xxErrorRateAverage", []))

    @jsii.member(jsii_name="metricCacheHitRateAverageInPercent")
    def metric_cache_hit_rate_average_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Cache hit rate metric.

        This is an additional metric that needs to be explicitly enabled for an additional cost.

        :see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCacheHitRateAverageInPercent", []))

    @jsii.member(jsii_name="metricRequestCount")
    def metric_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRequestCount", []))

    @jsii.member(jsii_name="metricRequestRate")
    def metric_request_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRequestRate", []))

    @jsii.member(jsii_name="metricRequestTps")
    def metric_request_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricRequestRate

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRequestTps", []))

    @jsii.member(jsii_name="metricTotalBytesDownloaded")
    def metric_total_bytes_downloaded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalBytesDownloaded", []))

    @jsii.member(jsii_name="metricTotalBytesUploaded")
    def metric_total_bytes_uploaded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalBytesUploaded", []))

    @jsii.member(jsii_name="metricTotalErrorRateAverage")
    def metric_total_error_rate_average(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalErrorRateAverage", []))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CloudFrontDistributionMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "distribution": "distribution",
        "additional_metrics_enabled": "additionalMetricsEnabled",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class CloudFrontDistributionMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
        additional_metrics_enabled: typing.Optional[builtins.bool] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param distribution: 
        :param additional_metrics_enabled: (experimental) Generate dashboard charts for additional CloudFront distribution metrics. To enable additional metrics on your CloudFront distribution, see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional Default: - true
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c62e4f3c4f2a6d30b58488d308c3dd35c2fcf1d3331e1c833b4decdc502e0db2)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument distribution", value=distribution, expected_type=type_hints["distribution"])
            check_type(argname="argument additional_metrics_enabled", value=additional_metrics_enabled, expected_type=type_hints["additional_metrics_enabled"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "distribution": distribution,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if additional_metrics_enabled is not None:
            self._values["additional_metrics_enabled"] = additional_metrics_enabled
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def distribution(self) -> _aws_cdk_aws_cloudfront_ceddda9d.IDistribution:
        '''
        :stability: experimental
        '''
        result = self._values.get("distribution")
        assert result is not None, "Required property 'distribution' is missing"
        return typing.cast(_aws_cdk_aws_cloudfront_ceddda9d.IDistribution, result)

    @builtins.property
    def additional_metrics_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Generate dashboard charts for additional CloudFront distribution metrics.

        To enable additional metrics on your CloudFront distribution, see
        https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("additional_metrics_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional["RateComputationMethod"]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional["RateComputationMethod"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CloudFrontDistributionMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CloudWatchLogsMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CloudWatchLogsMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        log_group_name: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param log_group_name: (experimental) Name of the log group to monitor.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__132d4f88ef2dd98258ecf737ed4053a56e55a5bac58f99139eca25252c965ec9)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = CloudWatchLogsMetricFactoryProps(
            log_group_name=log_group_name, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricIncomingLogEvents")
    def metric_incoming_log_events(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingLogEvents", []))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CloudWatchLogsMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "log_group_name": "logGroupName",
    },
)
class CloudWatchLogsMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        log_group_name: builtins.str,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param log_group_name: (experimental) Name of the log group to monitor.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62ff5f24f59a5f1f7bec002b977c9b749b44eff7b5bd8f7a1753bef6d0463227)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument log_group_name", value=log_group_name, expected_type=type_hints["log_group_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "log_group_name": log_group_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_group_name(self) -> builtins.str:
        '''(experimental) Name of the log group to monitor.

        :stability: experimental
        '''
        result = self._values.get("log_group_name")
        assert result is not None, "Required property 'log_group_name' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CloudWatchLogsMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CodeBuildProjectMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CodeBuildProjectMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param project: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6882a6e0b4d9af8419c13145a314aa19c28a50b6044640cdb6fd6cdcb778212)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = CodeBuildProjectMetricFactoryProps(
            project=project, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricBuildCount")
    def metric_build_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricBuildCount", []))

    @jsii.member(jsii_name="metricDurationP50InSeconds")
    def metric_duration_p50_in_seconds(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDurationP50InSeconds", []))

    @jsii.member(jsii_name="metricDurationP90InSeconds")
    def metric_duration_p90_in_seconds(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDurationP90InSeconds", []))

    @jsii.member(jsii_name="metricDurationP99InSeconds")
    def metric_duration_p99_in_seconds(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDurationP99InSeconds", []))

    @jsii.member(jsii_name="metricFailedBuildCount")
    def metric_failed_build_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFailedBuildCount", []))

    @jsii.member(jsii_name="metricFailedBuildRate")
    def metric_failed_build_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFailedBuildRate", []))

    @jsii.member(jsii_name="metricSucceededBuildCount")
    def metric_succeeded_build_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSucceededBuildCount", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="project")
    def _project(self) -> _aws_cdk_aws_codebuild_ceddda9d.IProject:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_codebuild_ceddda9d.IProject, jsii.get(self, "project"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CodeBuildProjectMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "project": "project"},
)
class CodeBuildProjectMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param project: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a7ad72f83c2048841ad0d74a88559e7732be4ff93729f3422257c091d44af36)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "project": project,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def project(self) -> _aws_cdk_aws_codebuild_ceddda9d.IProject:
        '''
        :stability: experimental
        '''
        result = self._values.get("project")
        assert result is not None, "Required property 'project' is missing"
        return typing.cast(_aws_cdk_aws_codebuild_ceddda9d.IProject, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CodeBuildProjectMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.CompositeAlarmOperator")
class CompositeAlarmOperator(enum.Enum):
    '''
    :stability: experimental
    '''

    AND = "AND"
    '''(experimental) trigger only if all the alarms are triggered.

    :stability: experimental
    '''
    OR = "OR"
    '''(experimental) trigger if any of the alarms is triggered.

    :stability: experimental
    '''


class ConnectionAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ConnectionAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1a1c5ddf32a40f63f59e22a5da82a7d60c1f420ffc263c51d8c4a36f47a9071)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxConnectionCountAlarm")
    def add_max_connection_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["HighConnectionCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a142674c555acbf9fc18df0264b147e50496559a37b5446e32196d27409f6a0)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxConnectionCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinConnectionCountAlarm")
    def add_min_connection_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["LowConnectionCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__40bf0e6097ca47d51c20f138fde28f5e7f35ea7a08063bbd9a73b152b873a211)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinConnectionCountAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class CustomAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CustomAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__842fd90292303bf62a261b8bcaf342b053b2038bf348e7fb77eecda1e2e1d44e)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addCustomAlarm")
    def add_custom_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_name_suffix: builtins.str,
        disambiguator: builtins.str,
        *,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        additional_description: typing.Optional[builtins.str] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param alarm_name_suffix: -
        :param disambiguator: -
        :param comparison_operator: 
        :param threshold: 
        :param additional_description: 
        :param dedupe_string: 
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__92ff4f0824fe03c42a578a27e0ce8f4509ba6900a2d8a593b6c1ab952b524c5b)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument alarm_name_suffix", value=alarm_name_suffix, expected_type=type_hints["alarm_name_suffix"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        props = CustomThreshold(
            comparison_operator=comparison_operator,
            threshold=threshold,
            additional_description=additional_description,
            dedupe_string=dedupe_string,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            comparison_operator_override=comparison_operator_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
            treat_missing_data_override=treat_missing_data_override,
        )

        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addCustomAlarm", [metric, alarm_name_suffix, disambiguator, props]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomAlarmThreshold",
    jsii_struct_bases=[],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
    },
)
class CustomAlarmThreshold:
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    ) -> None:
        '''(experimental) Common customization that can be attached to each alarm.

        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f608122ff7ce6fe8ec364084d27bd6e7336b135d26229dfb9e896b2591630613)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomAlarmThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMetricGroup",
    jsii_struct_bases=[],
    name_mapping={
        "metrics": "metrics",
        "title": "title",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "graph_widget_axis": "graphWidgetAxis",
        "graph_widget_legend": "graphWidgetLegend",
        "graph_widget_right_axis": "graphWidgetRightAxis",
        "graph_widget_set_period_to_time_range": "graphWidgetSetPeriodToTimeRange",
        "graph_widget_type": "graphWidgetType",
        "graph_widget_width": "graphWidgetWidth",
        "horizontal_annotations": "horizontalAnnotations",
        "horizontal_right_annotations": "horizontalRightAnnotations",
        "important": "important",
        "vertical_annotations": "verticalAnnotations",
    },
)
class CustomMetricGroup:
    def __init__(
        self,
        *,
        metrics: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, typing.Union["CustomMetricWithAlarm", typing.Dict[builtins.str, typing.Any]], typing.Union["CustomMetricWithAnomalyDetection", typing.Dict[builtins.str, typing.Any]], typing.Union["CustomMetricSearch", typing.Dict[builtins.str, typing.Any]]]],
        title: builtins.str,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        graph_widget_axis: typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]]] = None,
        graph_widget_legend: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.LegendPosition] = None,
        graph_widget_right_axis: typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]]] = None,
        graph_widget_set_period_to_time_range: typing.Optional[builtins.bool] = None,
        graph_widget_type: typing.Optional["GraphWidgetType"] = None,
        graph_widget_width: typing.Optional[jsii.Number] = None,
        horizontal_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        horizontal_right_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        important: typing.Optional[builtins.bool] = None,
        vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''(experimental) Custom metric group represents a single widget.

        :param metrics: (experimental) list of metrics in the group (can be defined in different ways, see the type documentation).
        :param title: (experimental) title of the whole group.
        :param add_to_summary_dashboard: (experimental) Flag indicating this metric group should be included in the summary as well. Default: - addToSummaryDashboard from CustomMonitoringProps, defaulting to false
        :param graph_widget_axis: (experimental) optional axis. Default: undefined
        :param graph_widget_legend: (experimental) graph widget legend. Default: BOTTOM
        :param graph_widget_right_axis: (experimental) optional right axis. Default: undefined
        :param graph_widget_set_period_to_time_range: 
        :param graph_widget_type: (experimental) type of the widget. Default: line
        :param graph_widget_width: (experimental) Width of graph widget. Note that widgets will overflow into new rows if the summed width exceeds 24. Default: - Automatically calculcated width, generally as wide as possible considering all metrics' widgets.
        :param horizontal_annotations: (experimental) Optional custom horizontal annotations which will be displayed over the metrics on the left axis (if there are any alarms, any existing annotations will be merged together).
        :param horizontal_right_annotations: (experimental) Optional custom horizontal annotations which will be displayed over the metrics on the right axis (if there are any alarms, any existing annotations will be merged together).
        :param important: 
        :param vertical_annotations: (experimental) Optional custom vertical annotations which will be displayed over the metrics.

        :stability: experimental
        '''
        if isinstance(graph_widget_axis, dict):
            graph_widget_axis = _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps(**graph_widget_axis)
        if isinstance(graph_widget_right_axis, dict):
            graph_widget_right_axis = _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps(**graph_widget_right_axis)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1f1bb77a9f08688389701943793f9fa232e3af630420ea5ad5a5613e0ececc4)
            check_type(argname="argument metrics", value=metrics, expected_type=type_hints["metrics"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument graph_widget_axis", value=graph_widget_axis, expected_type=type_hints["graph_widget_axis"])
            check_type(argname="argument graph_widget_legend", value=graph_widget_legend, expected_type=type_hints["graph_widget_legend"])
            check_type(argname="argument graph_widget_right_axis", value=graph_widget_right_axis, expected_type=type_hints["graph_widget_right_axis"])
            check_type(argname="argument graph_widget_set_period_to_time_range", value=graph_widget_set_period_to_time_range, expected_type=type_hints["graph_widget_set_period_to_time_range"])
            check_type(argname="argument graph_widget_type", value=graph_widget_type, expected_type=type_hints["graph_widget_type"])
            check_type(argname="argument graph_widget_width", value=graph_widget_width, expected_type=type_hints["graph_widget_width"])
            check_type(argname="argument horizontal_annotations", value=horizontal_annotations, expected_type=type_hints["horizontal_annotations"])
            check_type(argname="argument horizontal_right_annotations", value=horizontal_right_annotations, expected_type=type_hints["horizontal_right_annotations"])
            check_type(argname="argument important", value=important, expected_type=type_hints["important"])
            check_type(argname="argument vertical_annotations", value=vertical_annotations, expected_type=type_hints["vertical_annotations"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "metrics": metrics,
            "title": title,
        }
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if graph_widget_axis is not None:
            self._values["graph_widget_axis"] = graph_widget_axis
        if graph_widget_legend is not None:
            self._values["graph_widget_legend"] = graph_widget_legend
        if graph_widget_right_axis is not None:
            self._values["graph_widget_right_axis"] = graph_widget_right_axis
        if graph_widget_set_period_to_time_range is not None:
            self._values["graph_widget_set_period_to_time_range"] = graph_widget_set_period_to_time_range
        if graph_widget_type is not None:
            self._values["graph_widget_type"] = graph_widget_type
        if graph_widget_width is not None:
            self._values["graph_widget_width"] = graph_widget_width
        if horizontal_annotations is not None:
            self._values["horizontal_annotations"] = horizontal_annotations
        if horizontal_right_annotations is not None:
            self._values["horizontal_right_annotations"] = horizontal_right_annotations
        if important is not None:
            self._values["important"] = important
        if vertical_annotations is not None:
            self._values["vertical_annotations"] = vertical_annotations

    @builtins.property
    def metrics(
        self,
    ) -> typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, "CustomMetricWithAlarm", "CustomMetricWithAnomalyDetection", "CustomMetricSearch"]]:
        '''(experimental) list of metrics in the group (can be defined in different ways, see the type documentation).

        :stability: experimental
        '''
        result = self._values.get("metrics")
        assert result is not None, "Required property 'metrics' is missing"
        return typing.cast(typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, "CustomMetricWithAlarm", "CustomMetricWithAnomalyDetection", "CustomMetricSearch"]], result)

    @builtins.property
    def title(self) -> builtins.str:
        '''(experimental) title of the whole group.

        :stability: experimental
        '''
        result = self._values.get("title")
        assert result is not None, "Required property 'title' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating this metric group should be included in the summary as well.

        :default: - addToSummaryDashboard from CustomMonitoringProps, defaulting to false

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def graph_widget_axis(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps]:
        '''(experimental) optional axis.

        :default: undefined

        :stability: experimental
        '''
        result = self._values.get("graph_widget_axis")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps], result)

    @builtins.property
    def graph_widget_legend(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.LegendPosition]:
        '''(experimental) graph widget legend.

        :default: BOTTOM

        :stability: experimental
        '''
        result = self._values.get("graph_widget_legend")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.LegendPosition], result)

    @builtins.property
    def graph_widget_right_axis(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps]:
        '''(experimental) optional right axis.

        :default: undefined

        :stability: experimental
        '''
        result = self._values.get("graph_widget_right_axis")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps], result)

    @builtins.property
    def graph_widget_set_period_to_time_range(self) -> typing.Optional[builtins.bool]:
        '''
        :see: {GraphWidgetProps.setPeriodToTimeRange}
        :stability: experimental
        '''
        result = self._values.get("graph_widget_set_period_to_time_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def graph_widget_type(self) -> typing.Optional["GraphWidgetType"]:
        '''(experimental) type of the widget.

        :default: line

        :stability: experimental
        '''
        result = self._values.get("graph_widget_type")
        return typing.cast(typing.Optional["GraphWidgetType"], result)

    @builtins.property
    def graph_widget_width(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Width of graph widget.

        Note that widgets will overflow into new rows if the summed width
        exceeds 24.

        :default: - Automatically calculcated width, generally as wide as possible considering all metrics' widgets.

        :stability: experimental
        '''
        result = self._values.get("graph_widget_width")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def horizontal_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]]:
        '''(experimental) Optional custom horizontal annotations which will be displayed over the metrics on the left axis (if there are any alarms, any existing annotations will be merged together).

        :stability: experimental
        '''
        result = self._values.get("horizontal_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]], result)

    @builtins.property
    def horizontal_right_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]]:
        '''(experimental) Optional custom horizontal annotations which will be displayed over the metrics on the right axis (if there are any alarms, any existing annotations will be merged together).

        :stability: experimental
        '''
        result = self._values.get("horizontal_right_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]], result)

    @builtins.property
    def important(self) -> typing.Optional[builtins.bool]:
        '''
        :deprecated: use addToSummaryDashboard. addToSummaryDashboard will take precedence over important.

        :see: addToSummaryDashboard
        :stability: deprecated
        '''
        result = self._values.get("important")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def vertical_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]]:
        '''(experimental) Optional custom vertical annotations which will be displayed over the metrics.

        :stability: experimental
        '''
        result = self._values.get("vertical_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMetricGroup(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMetricGroupWithAnnotations",
    jsii_struct_bases=[],
    name_mapping={
        "annotations": "annotations",
        "metric_group": "metricGroup",
        "right_annotations": "rightAnnotations",
        "title_addons": "titleAddons",
        "vertical_annotations": "verticalAnnotations",
        "height": "height",
    },
)
class CustomMetricGroupWithAnnotations:
    def __init__(
        self,
        *,
        annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]],
        metric_group: typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]],
        right_annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]],
        title_addons: typing.Sequence[builtins.str],
        vertical_annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]],
        height: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param annotations: 
        :param metric_group: 
        :param right_annotations: 
        :param title_addons: 
        :param vertical_annotations: 
        :param height: 

        :stability: experimental
        '''
        if isinstance(metric_group, dict):
            metric_group = CustomMetricGroup(**metric_group)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7619d758dc272ff2b4dce9aa14e3ace0f18384f3dc45801e8569a8e01ebe8da9)
            check_type(argname="argument annotations", value=annotations, expected_type=type_hints["annotations"])
            check_type(argname="argument metric_group", value=metric_group, expected_type=type_hints["metric_group"])
            check_type(argname="argument right_annotations", value=right_annotations, expected_type=type_hints["right_annotations"])
            check_type(argname="argument title_addons", value=title_addons, expected_type=type_hints["title_addons"])
            check_type(argname="argument vertical_annotations", value=vertical_annotations, expected_type=type_hints["vertical_annotations"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "annotations": annotations,
            "metric_group": metric_group,
            "right_annotations": right_annotations,
            "title_addons": title_addons,
            "vertical_annotations": vertical_annotations,
        }
        if height is not None:
            self._values["height"] = height

    @builtins.property
    def annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        result = self._values.get("annotations")
        assert result is not None, "Required property 'annotations' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], result)

    @builtins.property
    def metric_group(self) -> CustomMetricGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("metric_group")
        assert result is not None, "Required property 'metric_group' is missing"
        return typing.cast(CustomMetricGroup, result)

    @builtins.property
    def right_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        result = self._values.get("right_annotations")
        assert result is not None, "Required property 'right_annotations' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], result)

    @builtins.property
    def title_addons(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("title_addons")
        assert result is not None, "Required property 'title_addons' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def vertical_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]:
        '''
        :stability: experimental
        '''
        result = self._values.get("vertical_annotations")
        assert result is not None, "Required property 'vertical_annotations' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation], result)

    @builtins.property
    def height(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("height")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMetricGroupWithAnnotations(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMetricSearch",
    jsii_struct_bases=[],
    name_mapping={
        "dimensions_map": "dimensionsMap",
        "search_query": "searchQuery",
        "statistic": "statistic",
        "account": "account",
        "label": "label",
        "namespace": "namespace",
        "period": "period",
        "position": "position",
        "region": "region",
    },
)
class CustomMetricSearch:
    def __init__(
        self,
        *,
        dimensions_map: typing.Mapping[builtins.str, builtins.str],
        search_query: builtins.str,
        statistic: "MetricStatistic",
        account: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        namespace: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        position: typing.Optional[AxisPosition] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Custom metric search.

        :param dimensions_map: (experimental) search dimensions (can be empty).
        :param search_query: (experimental) search query (can be empty).
        :param statistic: (experimental) metric statistic.
        :param account: (experimental) Account which this metric comes from. Note that alarms cannot be created for cross-account metrics. Default: - Deployment account.
        :param label: (experimental) custom label for the metrics. Default: - " "
        :param namespace: (experimental) metric namespace. Default: - none
        :param period: (experimental) metric period. Default: - global default
        :param position: (experimental) axis (right or left) on which to graph metric default: AxisPosition.LEFT.
        :param region: (experimental) Region which this metric comes from. Note that alarms cannot be created for cross-region metrics. Default: - Deployment region.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__63182d2487fd8c5519734296bd6fa20b09a86af420cdcfc68cf5fdce11729f57)
            check_type(argname="argument dimensions_map", value=dimensions_map, expected_type=type_hints["dimensions_map"])
            check_type(argname="argument search_query", value=search_query, expected_type=type_hints["search_query"])
            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument position", value=position, expected_type=type_hints["position"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "dimensions_map": dimensions_map,
            "search_query": search_query,
            "statistic": statistic,
        }
        if account is not None:
            self._values["account"] = account
        if label is not None:
            self._values["label"] = label
        if namespace is not None:
            self._values["namespace"] = namespace
        if period is not None:
            self._values["period"] = period
        if position is not None:
            self._values["position"] = position
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) search dimensions (can be empty).

        :stability: experimental
        '''
        result = self._values.get("dimensions_map")
        assert result is not None, "Required property 'dimensions_map' is missing"
        return typing.cast(typing.Mapping[builtins.str, builtins.str], result)

    @builtins.property
    def search_query(self) -> builtins.str:
        '''(experimental) search query (can be empty).

        :stability: experimental
        '''
        result = self._values.get("search_query")
        assert result is not None, "Required property 'search_query' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def statistic(self) -> "MetricStatistic":
        '''(experimental) metric statistic.

        :stability: experimental
        '''
        result = self._values.get("statistic")
        assert result is not None, "Required property 'statistic' is missing"
        return typing.cast("MetricStatistic", result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account which this metric comes from.

        Note that alarms cannot be created for cross-account metrics.

        :default: - Deployment account.

        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def label(self) -> typing.Optional[builtins.str]:
        '''(experimental) custom label for the metrics.

        :default: - " "

        :stability: experimental
        '''
        result = self._values.get("label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) metric namespace.

        :default: - none

        :stability: experimental
        '''
        result = self._values.get("namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) metric period.

        :default: - global default

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def position(self) -> typing.Optional[AxisPosition]:
        '''(experimental) axis (right or left) on which to graph metric default: AxisPosition.LEFT.

        :stability: experimental
        '''
        result = self._values.get("position")
        return typing.cast(typing.Optional[AxisPosition], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region which this metric comes from.

        Note that alarms cannot be created for cross-region metrics.

        :default: - Deployment region.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMetricSearch(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMetricWithAlarm",
    jsii_struct_bases=[],
    name_mapping={
        "add_alarm": "addAlarm",
        "alarm_friendly_name": "alarmFriendlyName",
        "metric": "metric",
        "position": "position",
    },
)
class CustomMetricWithAlarm:
    def __init__(
        self,
        *,
        add_alarm: typing.Mapping[builtins.str, typing.Union["CustomThreshold", typing.Dict[builtins.str, typing.Any]]],
        alarm_friendly_name: builtins.str,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        position: typing.Optional[AxisPosition] = None,
    ) -> None:
        '''(experimental) Custom metric with an alarm defined.

        :param add_alarm: (experimental) alarm definitions.
        :param alarm_friendly_name: (experimental) alarm friendly name.
        :param metric: (experimental) metric to alarm on.
        :param position: (experimental) axis (right or left) on which to graph metric default: AxisPosition.LEFT.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c50968ffe9bb26017e4152c62ead0d70defc2d1fb006cee54d51da2655be411c)
            check_type(argname="argument add_alarm", value=add_alarm, expected_type=type_hints["add_alarm"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument position", value=position, expected_type=type_hints["position"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "add_alarm": add_alarm,
            "alarm_friendly_name": alarm_friendly_name,
            "metric": metric,
        }
        if position is not None:
            self._values["position"] = position

    @builtins.property
    def add_alarm(self) -> typing.Mapping[builtins.str, "CustomThreshold"]:
        '''(experimental) alarm definitions.

        :stability: experimental
        '''
        result = self._values.get("add_alarm")
        assert result is not None, "Required property 'add_alarm' is missing"
        return typing.cast(typing.Mapping[builtins.str, "CustomThreshold"], result)

    @builtins.property
    def alarm_friendly_name(self) -> builtins.str:
        '''(experimental) alarm friendly name.

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        assert result is not None, "Required property 'alarm_friendly_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) metric to alarm on.

        :stability: experimental
        '''
        result = self._values.get("metric")
        assert result is not None, "Required property 'metric' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], result)

    @builtins.property
    def position(self) -> typing.Optional[AxisPosition]:
        '''(experimental) axis (right or left) on which to graph metric default: AxisPosition.LEFT.

        :stability: experimental
        '''
        result = self._values.get("position")
        return typing.cast(typing.Optional[AxisPosition], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMetricWithAlarm(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMetricWithAnomalyDetection",
    jsii_struct_bases=[],
    name_mapping={
        "alarm_friendly_name": "alarmFriendlyName",
        "anomaly_detection_standard_deviation_to_render": "anomalyDetectionStandardDeviationToRender",
        "metric": "metric",
        "add_alarm_on_anomaly": "addAlarmOnAnomaly",
        "period": "period",
    },
)
class CustomMetricWithAnomalyDetection:
    def __init__(
        self,
        *,
        alarm_friendly_name: builtins.str,
        anomaly_detection_standard_deviation_to_render: jsii.Number,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        add_alarm_on_anomaly: typing.Optional[typing.Mapping[builtins.str, typing.Union["AnomalyDetectionThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''(experimental) Custom metric with anomaly detection.

        :param alarm_friendly_name: (experimental) alarm friendly name.
        :param anomaly_detection_standard_deviation_to_render: (experimental) standard deviation for the anomaly detection to be rendered on the graph widget.
        :param metric: (experimental) metric to alarm on.
        :param add_alarm_on_anomaly: (experimental) adds alarm on a detected anomaly.
        :param period: (experimental) anomaly detection period. Default: - metric period (if defined) or global default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd04f74ccbaa026d25c1b7ddcdbd55714e125815b7244320fa40a7823c5e4847)
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument anomaly_detection_standard_deviation_to_render", value=anomaly_detection_standard_deviation_to_render, expected_type=type_hints["anomaly_detection_standard_deviation_to_render"])
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument add_alarm_on_anomaly", value=add_alarm_on_anomaly, expected_type=type_hints["add_alarm_on_anomaly"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_friendly_name": alarm_friendly_name,
            "anomaly_detection_standard_deviation_to_render": anomaly_detection_standard_deviation_to_render,
            "metric": metric,
        }
        if add_alarm_on_anomaly is not None:
            self._values["add_alarm_on_anomaly"] = add_alarm_on_anomaly
        if period is not None:
            self._values["period"] = period

    @builtins.property
    def alarm_friendly_name(self) -> builtins.str:
        '''(experimental) alarm friendly name.

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        assert result is not None, "Required property 'alarm_friendly_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def anomaly_detection_standard_deviation_to_render(self) -> jsii.Number:
        '''(experimental) standard deviation for the anomaly detection to be rendered on the graph widget.

        :stability: experimental
        '''
        result = self._values.get("anomaly_detection_standard_deviation_to_render")
        assert result is not None, "Required property 'anomaly_detection_standard_deviation_to_render' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) metric to alarm on.

        :stability: experimental
        '''
        result = self._values.get("metric")
        assert result is not None, "Required property 'metric' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], result)

    @builtins.property
    def add_alarm_on_anomaly(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "AnomalyDetectionThreshold"]]:
        '''(experimental) adds alarm on a detected anomaly.

        :stability: experimental
        '''
        result = self._values.get("add_alarm_on_anomaly")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "AnomalyDetectionThreshold"]], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) anomaly detection period.

        :default: - metric period (if defined) or global default

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMetricWithAnomalyDetection(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "comparison_operator": "comparisonOperator",
        "threshold": "threshold",
        "additional_description": "additionalDescription",
        "dedupe_string": "dedupeString",
    },
)
class CustomThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        additional_description: typing.Optional[builtins.str] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param comparison_operator: 
        :param threshold: 
        :param additional_description: 
        :param dedupe_string: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86d5216a650bd624bbb710741fab50af24cb71cd64afb9218797c39b3d0b776e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument comparison_operator", value=comparison_operator, expected_type=type_hints["comparison_operator"])
            check_type(argname="argument threshold", value=threshold, expected_type=type_hints["threshold"])
            check_type(argname="argument additional_description", value=additional_description, expected_type=type_hints["additional_description"])
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "comparison_operator": comparison_operator,
            "threshold": threshold,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override
        if additional_description is not None:
            self._values["additional_description"] = additional_description
        if dedupe_string is not None:
            self._values["dedupe_string"] = dedupe_string

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def comparison_operator(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator:
        '''
        :stability: experimental
        '''
        result = self._values.get("comparison_operator")
        assert result is not None, "Required property 'comparison_operator' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator, result)

    @builtins.property
    def threshold(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("threshold")
        assert result is not None, "Required property 'threshold' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def additional_description(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("additional_description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dedupe_string(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CustomWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.ConcreteWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CustomWidget",
):
    '''(experimental) A dashboard widget that can be customized using a Lambda.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        handler: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        handler_params: typing.Any = None,
        height: typing.Optional[jsii.Number] = None,
        title: typing.Optional[builtins.str] = None,
        update_on_refresh: typing.Optional[builtins.bool] = None,
        update_on_resize: typing.Optional[builtins.bool] = None,
        update_on_time_range_change: typing.Optional[builtins.bool] = None,
        width: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param handler: (experimental) Lambda providing the widget contents. The Lambda function should return HTML with widget code. The simplest Lambda example:: exports.handler = function (event, context, callback) { return callback(null, "<h1>Hello! This is a custom widget.</h1><pre>" + JSON.stringify(event, null, 2) + "</pre>"); };
        :param handler_params: (experimental) Arguments to pass to the Lambda. These arguments will be available in the Lambda context.
        :param height: (experimental) Height of the widget. Default: - 6
        :param title: (experimental) Title for the graph.
        :param update_on_refresh: (experimental) Whether the widget should be updated (by calling the Lambda again) on refresh. Default: - true
        :param update_on_resize: (experimental) Whether the widget should be updated (by calling the Lambda again) on resize. Default: - true
        :param update_on_time_range_change: (experimental) Whether the widget should be updated (by calling the Lambda again) on time range change. Default: - true
        :param width: (experimental) Width of the widget, in a grid of 24 units wide. Default: - 6

        :stability: experimental
        '''
        props = CustomWidgetProps(
            handler=handler,
            handler_params=handler_params,
            height=height,
            title=title,
            update_on_refresh=update_on_refresh,
            update_on_resize=update_on_resize,
            update_on_time_range_change=update_on_time_range_change,
            width=width,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="toJson")
    def to_json(self) -> typing.List[typing.Any]:
        '''(experimental) Return the widget JSON for use in the dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Any], jsii.invoke(self, "toJson", []))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomWidgetProps",
    jsii_struct_bases=[],
    name_mapping={
        "handler": "handler",
        "handler_params": "handlerParams",
        "height": "height",
        "title": "title",
        "update_on_refresh": "updateOnRefresh",
        "update_on_resize": "updateOnResize",
        "update_on_time_range_change": "updateOnTimeRangeChange",
        "width": "width",
    },
)
class CustomWidgetProps:
    def __init__(
        self,
        *,
        handler: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        handler_params: typing.Any = None,
        height: typing.Optional[jsii.Number] = None,
        title: typing.Optional[builtins.str] = None,
        update_on_refresh: typing.Optional[builtins.bool] = None,
        update_on_resize: typing.Optional[builtins.bool] = None,
        update_on_time_range_change: typing.Optional[builtins.bool] = None,
        width: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Properties of a custom widget.

        :param handler: (experimental) Lambda providing the widget contents. The Lambda function should return HTML with widget code. The simplest Lambda example:: exports.handler = function (event, context, callback) { return callback(null, "<h1>Hello! This is a custom widget.</h1><pre>" + JSON.stringify(event, null, 2) + "</pre>"); };
        :param handler_params: (experimental) Arguments to pass to the Lambda. These arguments will be available in the Lambda context.
        :param height: (experimental) Height of the widget. Default: - 6
        :param title: (experimental) Title for the graph.
        :param update_on_refresh: (experimental) Whether the widget should be updated (by calling the Lambda again) on refresh. Default: - true
        :param update_on_resize: (experimental) Whether the widget should be updated (by calling the Lambda again) on resize. Default: - true
        :param update_on_time_range_change: (experimental) Whether the widget should be updated (by calling the Lambda again) on time range change. Default: - true
        :param width: (experimental) Width of the widget, in a grid of 24 units wide. Default: - 6

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__531a5bc64d0774422bc4d022016267f620d37e8f4fff3d351a5fa8bfdf1b6f6c)
            check_type(argname="argument handler", value=handler, expected_type=type_hints["handler"])
            check_type(argname="argument handler_params", value=handler_params, expected_type=type_hints["handler_params"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument update_on_refresh", value=update_on_refresh, expected_type=type_hints["update_on_refresh"])
            check_type(argname="argument update_on_resize", value=update_on_resize, expected_type=type_hints["update_on_resize"])
            check_type(argname="argument update_on_time_range_change", value=update_on_time_range_change, expected_type=type_hints["update_on_time_range_change"])
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "handler": handler,
        }
        if handler_params is not None:
            self._values["handler_params"] = handler_params
        if height is not None:
            self._values["height"] = height
        if title is not None:
            self._values["title"] = title
        if update_on_refresh is not None:
            self._values["update_on_refresh"] = update_on_refresh
        if update_on_resize is not None:
            self._values["update_on_resize"] = update_on_resize
        if update_on_time_range_change is not None:
            self._values["update_on_time_range_change"] = update_on_time_range_change
        if width is not None:
            self._values["width"] = width

    @builtins.property
    def handler(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''(experimental) Lambda providing the widget contents.

        The Lambda function should return HTML with widget code.
        The simplest Lambda example::

           exports.handler = function (event, context, callback) {
              return callback(null, "<h1>Hello! This is a custom widget.</h1><pre>" + JSON.stringify(event, null, 2) + "</pre>");
           };

        :stability: experimental
        '''
        result = self._values.get("handler")
        assert result is not None, "Required property 'handler' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    @builtins.property
    def handler_params(self) -> typing.Any:
        '''(experimental) Arguments to pass to the Lambda.

        These arguments will be available in the Lambda context.

        :stability: experimental
        '''
        result = self._values.get("handler_params")
        return typing.cast(typing.Any, result)

    @builtins.property
    def height(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Height of the widget.

        :default: - 6

        :stability: experimental
        '''
        result = self._values.get("height")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''(experimental) Title for the graph.

        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def update_on_refresh(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether the widget should be updated (by calling the Lambda again) on refresh.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("update_on_refresh")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def update_on_resize(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether the widget should be updated (by calling the Lambda again) on resize.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("update_on_resize")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def update_on_time_range_change(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether the widget should be updated (by calling the Lambda again) on time range change.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("update_on_time_range_change")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def width(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Width of the widget, in a grid of 24 units wide.

        :default: - 6

        :stability: experimental
        '''
        result = self._values.get("width")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.DashboardRenderingPreference")
class DashboardRenderingPreference(enum.Enum):
    '''(experimental) Preferred way of rendering dashboard widgets.

    :stability: experimental
    '''

    INTERACTIVE_ONLY = "INTERACTIVE_ONLY"
    '''(experimental) Create standard set of dashboards with interactive widgets only.

    :stability: experimental
    '''
    BITMAP_ONLY = "BITMAP_ONLY"
    '''(experimental) Create standard set of dashboards with bitmap widgets only.

    :stability: experimental
    '''
    INTERACTIVE_AND_BITMAP = "INTERACTIVE_AND_BITMAP"
    '''(experimental) Create a two sets of dashboards: standard set (interactive) and a copy (bitmap).

    :stability: experimental
    '''


class DashboardWithBitmapCopy(
    _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DashboardWithBitmapCopy",
):
    '''(experimental) Composite dashboard which keeps a normal dashboard with its bitmap copy.

    The bitmap copy name will be derived from the primary dashboard name, if specified.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        dashboard_name: typing.Optional[builtins.str] = None,
        default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        end: typing.Optional[builtins.str] = None,
        period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        start: typing.Optional[builtins.str] = None,
        variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
        widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param dashboard_name: Name of the dashboard. If set, must only contain alphanumerics, dash (-) and underscore (_) Default: - automatically generated name
        :param default_interval: Interval duration for metrics. You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)). Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the defaultInterval time will be the default time range.
        :param end: The end of the time range to use for each widget on the dashboard when the dashboard loads. If you specify a value for end, you must also specify a value for start. Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Default: When the dashboard loads, the end date will be the current time.
        :param period_override: Use this field to specify the period for the graphs when the dashboard loads. Specifying ``Auto`` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard. Specifying ``Inherit`` ensures that the period set for each graph is always obeyed. Default: Auto
        :param start: The start of the time range to use for each widget on the dashboard. You can specify start without specifying end to specify a relative time range that ends with the current time. In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months. You can also use start along with an end field, to specify an absolute time range. When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the start time will be the default time range.
        :param variables: A list of dashboard variables. Default: - No variables
        :param widgets: Initial set of widgets on the dashboard. One array represents a row of widgets. Default: - No widgets

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efea1c7e65336fd9864d4a3b0a38ab06f6ddcae24f08fd2fe9bbec10ec81c98d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.DashboardProps(
            dashboard_name=dashboard_name,
            default_interval=default_interval,
            end=end,
            period_override=period_override,
            start=start,
            variables=variables,
            widgets=widgets,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addWidgets")
    def add_widgets(self, *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget) -> None:
        '''(experimental) Add a widget to the dashboard.

        Widgets given in multiple calls to add() will be laid out stacked on
        top of each other.

        Multiple widgets added in the same call to add() will be laid out next
        to each other.

        :param widgets: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__432599f8be82fbd24f8c0c66d2819b3704dac265c14e6d6541246f2bed6cc549)
            check_type(argname="argument widgets", value=widgets, expected_type=typing.Tuple[type_hints["widgets"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addWidgets", [*widgets]))

    @builtins.property
    @jsii.member(jsii_name="bitmapCopy")
    def _bitmap_copy(self) -> BitmapDashboard:
        '''
        :stability: experimental
        '''
        return typing.cast(BitmapDashboard, jsii.get(self, "bitmapCopy"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DaysSinceUpdateThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_days_since_update": "maxDaysSinceUpdate",
    },
)
class DaysSinceUpdateThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_days_since_update: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_days_since_update: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e7fe19ca3c7de381684ba80b4bc969bdd0f480630f5062050ed7e3e6059176e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_days_since_update", value=max_days_since_update, expected_type=type_hints["max_days_since_update"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_days_since_update": max_days_since_update,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_days_since_update(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_days_since_update")
        assert result is not None, "Required property 'max_days_since_update' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DaysSinceUpdateThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DaysToExpiryThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_days_to_expiry": "minDaysToExpiry",
    },
)
class DaysToExpiryThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_days_to_expiry: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_days_to_expiry: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a8ddb414e1cc2a15374c19ecfdf14ed7966b5d0b8066f5ac7e9dff750d06e2f)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_days_to_expiry", value=min_days_to_expiry, expected_type=type_hints["min_days_to_expiry"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_days_to_expiry": min_days_to_expiry,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_days_to_expiry(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_days_to_expiry")
        assert result is not None, "Required property 'min_days_to_expiry' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DaysToExpiryThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.DefaultDashboards")
class DefaultDashboards(enum.Enum):
    '''
    :stability: experimental
    '''

    SUMMARY = "SUMMARY"
    '''
    :stability: experimental
    '''
    DETAIL = "DETAIL"
    '''
    :stability: experimental
    '''
    ALARMS = "ALARMS"
    '''
    :stability: experimental
    '''


class DocumentDbMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DocumentDbMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param cluster: (experimental) database cluster.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f744557b86a3e2dd82ef0e8a3ff586154696228f1c5a43ce1d69e2c9c647f100)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = DocumentDbMetricFactoryProps(
            cluster=cluster, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCpuUsageInPercent")
    def metric_average_cpu_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageCpuUsageInPercent", []))

    @jsii.member(jsii_name="metricMaxConnectionCount")
    def metric_max_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxConnectionCount", []))

    @jsii.member(jsii_name="metricMaxCursorCount")
    def metric_max_cursor_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxCursorCount", []))

    @jsii.member(jsii_name="metricMaxTransactionOpenCount")
    def metric_max_transaction_open_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxTransactionOpenCount", []))

    @jsii.member(jsii_name="metricOperationsThrottledDueLowMemoryCount")
    def metric_operations_throttled_due_low_memory_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricOperationsThrottledDueLowMemoryCount", []))

    @jsii.member(jsii_name="metricReadLatencyInMillis")
    def metric_read_latency_in_millis(
        self,
        latency_type: "LatencyType",
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e314657e74051bf9e0b8cca0e6793875851d1c18b0733e51165864325ec76e3)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricWriteLatencyInMillis")
    def metric_write_latency_in_millis(
        self,
        latency_type: "LatencyType",
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5115987173ad680caf08db054b2ec113df00b3e96a66ec24def122a90b5b9827)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteLatencyInMillis", [latency_type]))

    @builtins.property
    @jsii.member(jsii_name="clusterIdentifier")
    def cluster_identifier(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "clusterIdentifier"))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DocumentDbMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "cluster": "cluster"},
)
class DocumentDbMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster: (experimental) database cluster.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__677e67c893b039647efeb1826c8d754873b3949c149bef9497417f2e4fea236e)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster": cluster,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster(self) -> _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster:
        '''(experimental) database cluster.

        :stability: experimental
        '''
        result = self._values.get("cluster")
        assert result is not None, "Required property 'cluster' is missing"
        return typing.cast(_aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DocumentDbMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DoubleAxisGraphWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DoubleAxisGraphWidget",
):
    '''(experimental) Line graph widget with both left and right axes.

    The purpose of this custom class is to make the properties more strict.
    It will avoid graphs with undefined axes and dimensions.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        height: jsii.Number,
        left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        right_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        right_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        width: jsii.Number,
        left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        right_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        title: typing.Optional[builtins.str] = None,
        vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param height: 
        :param left_axis: 
        :param left_metrics: 
        :param right_axis: 
        :param right_metrics: 
        :param width: 
        :param left_annotations: 
        :param right_annotations: 
        :param title: 
        :param vertical_annotations: 

        :stability: experimental
        '''
        props = DoubleAxisGraphWidgetProps(
            height=height,
            left_axis=left_axis,
            left_metrics=left_metrics,
            right_axis=right_axis,
            right_metrics=right_metrics,
            width=width,
            left_annotations=left_annotations,
            right_annotations=right_annotations,
            title=title,
            vertical_annotations=vertical_annotations,
        )

        jsii.create(self.__class__, self, [props])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DoubleAxisGraphWidgetProps",
    jsii_struct_bases=[],
    name_mapping={
        "height": "height",
        "left_axis": "leftAxis",
        "left_metrics": "leftMetrics",
        "right_axis": "rightAxis",
        "right_metrics": "rightMetrics",
        "width": "width",
        "left_annotations": "leftAnnotations",
        "right_annotations": "rightAnnotations",
        "title": "title",
        "vertical_annotations": "verticalAnnotations",
    },
)
class DoubleAxisGraphWidgetProps:
    def __init__(
        self,
        *,
        height: jsii.Number,
        left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        right_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        right_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        width: jsii.Number,
        left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        right_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        title: typing.Optional[builtins.str] = None,
        vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param height: 
        :param left_axis: 
        :param left_metrics: 
        :param right_axis: 
        :param right_metrics: 
        :param width: 
        :param left_annotations: 
        :param right_annotations: 
        :param title: 
        :param vertical_annotations: 

        :stability: experimental
        '''
        if isinstance(left_axis, dict):
            left_axis = _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps(**left_axis)
        if isinstance(right_axis, dict):
            right_axis = _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps(**right_axis)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a59f2f11bb83665e0b2fdf65e6a8a6781f794062ea2b2791fccf96a0d421324)
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
            check_type(argname="argument left_axis", value=left_axis, expected_type=type_hints["left_axis"])
            check_type(argname="argument left_metrics", value=left_metrics, expected_type=type_hints["left_metrics"])
            check_type(argname="argument right_axis", value=right_axis, expected_type=type_hints["right_axis"])
            check_type(argname="argument right_metrics", value=right_metrics, expected_type=type_hints["right_metrics"])
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument left_annotations", value=left_annotations, expected_type=type_hints["left_annotations"])
            check_type(argname="argument right_annotations", value=right_annotations, expected_type=type_hints["right_annotations"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument vertical_annotations", value=vertical_annotations, expected_type=type_hints["vertical_annotations"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "height": height,
            "left_axis": left_axis,
            "left_metrics": left_metrics,
            "right_axis": right_axis,
            "right_metrics": right_metrics,
            "width": width,
        }
        if left_annotations is not None:
            self._values["left_annotations"] = left_annotations
        if right_annotations is not None:
            self._values["right_annotations"] = right_annotations
        if title is not None:
            self._values["title"] = title
        if vertical_annotations is not None:
            self._values["vertical_annotations"] = vertical_annotations

    @builtins.property
    def height(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("height")
        assert result is not None, "Required property 'height' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def left_axis(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_axis")
        assert result is not None, "Required property 'left_axis' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, result)

    @builtins.property
    def left_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_metrics")
        assert result is not None, "Required property 'left_metrics' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], result)

    @builtins.property
    def right_axis(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps:
        '''
        :stability: experimental
        '''
        result = self._values.get("right_axis")
        assert result is not None, "Required property 'right_axis' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, result)

    @builtins.property
    def right_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        result = self._values.get("right_metrics")
        assert result is not None, "Required property 'right_metrics' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], result)

    @builtins.property
    def width(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("width")
        assert result is not None, "Required property 'width' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def left_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]], result)

    @builtins.property
    def right_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("right_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vertical_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("vertical_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DoubleAxisGraphWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DurationThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_duration": "maxDuration",
    },
)
class DurationThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_duration: _aws_cdk_ceddda9d.Duration,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_duration: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__24b978702f49c7ab143fcb30e1776a46fffc7f211ee09c8723117cae8f591c13)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_duration", value=max_duration, expected_type=type_hints["max_duration"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_duration": max_duration,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_duration(self) -> _aws_cdk_ceddda9d.Duration:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_duration")
        assert result is not None, "Required property 'max_duration' is missing"
        return typing.cast(_aws_cdk_ceddda9d.Duration, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DurationThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamicDashboardConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "name": "name",
        "period_override": "periodOverride",
        "range": "range",
        "rendering_preference": "renderingPreference",
    },
)
class DynamicDashboardConfiguration:
    def __init__(
        self,
        *,
        name: builtins.str,
        period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
    ) -> None:
        '''
        :param name: (experimental) Name of the dashboard. Full dashboard name will take the form of: ``{@link MonitoringDynamicDashboardsProps.dashboardNamePrefix}-{@link name}``. NOTE: The dashboard names in {@link DefaultDashboardFactory.DefaultDashboards} are reserved and cannot be used as dashboard names.
        :param period_override: (experimental) Period override for the dashboard. Default: - respect individual graphs (PeriodOverride.INHERIT)
        :param range: (experimental) Range of the dashboard. Default: - 8 hours
        :param rendering_preference: (experimental) Dashboard rendering preference. Default: - DashboardRenderingPreference.INTERACTIVE_ONLY

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d263102eec892d25eada86016f8607a70697f322c8d513e5025fc6197c7379b7)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument period_override", value=period_override, expected_type=type_hints["period_override"])
            check_type(argname="argument range", value=range, expected_type=type_hints["range"])
            check_type(argname="argument rendering_preference", value=rendering_preference, expected_type=type_hints["rendering_preference"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "name": name,
        }
        if period_override is not None:
            self._values["period_override"] = period_override
        if range is not None:
            self._values["range"] = range
        if rendering_preference is not None:
            self._values["rendering_preference"] = rendering_preference

    @builtins.property
    def name(self) -> builtins.str:
        '''(experimental) Name of the dashboard. Full dashboard name will take the form of: ``{@link MonitoringDynamicDashboardsProps.dashboardNamePrefix}-{@link name}``.

        NOTE: The dashboard names in {@link DefaultDashboardFactory.DefaultDashboards}
        are reserved and cannot be used as dashboard names.

        :stability: experimental
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def period_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride]:
        '''(experimental) Period override for the dashboard.

        :default: - respect individual graphs (PeriodOverride.INHERIT)

        :stability: experimental
        '''
        result = self._values.get("period_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride], result)

    @builtins.property
    def range(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Range of the dashboard.

        :default: - 8 hours

        :stability: experimental
        '''
        result = self._values.get("range")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def rendering_preference(self) -> typing.Optional[DashboardRenderingPreference]:
        '''(experimental) Dashboard rendering preference.

        :default: - DashboardRenderingPreference.INTERACTIVE_ONLY

        :stability: experimental
        '''
        result = self._values.get("rendering_preference")
        return typing.cast(typing.Optional[DashboardRenderingPreference], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamicDashboardConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DynamoAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamoAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7c6b95e38184075c84ce55e5a093bc8065febb005edac9203aa9c991822caab)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addConsumedCapacityAlarm")
    def add_consumed_capacity_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        capacity_type: CapacityType,
        props: typing.Union["ConsumedCapacityThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param capacity_type: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf23b15019ca557aae9164b0b671eea28217d46e93d7ef6cb1fab55251f01636)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument capacity_type", value=capacity_type, expected_type=type_hints["capacity_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addConsumedCapacityAlarm", [metric, capacity_type, props, disambiguator]))

    @jsii.member(jsii_name="addThrottledEventsAlarm")
    def add_throttled_events_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        capacity_type: CapacityType,
        props: typing.Union["ThrottledEventsThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param capacity_type: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1346d3b1420f0068f0efa6e6040ee42ddc2f695f04a37dd8da4bbc573b550e64)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument capacity_type", value=capacity_type, expected_type=type_hints["capacity_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addThrottledEventsAlarm", [metric, capacity_type, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class DynamoTableGlobalSecondaryIndexMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamoTableGlobalSecondaryIndexMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        global_secondary_index_name: builtins.str,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param global_secondary_index_name: 
        :param table: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e3547a89f425dbd496a2b79f75bf6e4cb7065cc8e8d0a72a07889a701459e17)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = DynamoTableGlobalSecondaryIndexMetricFactoryProps(
            global_secondary_index_name=global_secondary_index_name,
            table=table,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricConsumedReadCapacityUnits")
    def metric_consumed_read_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConsumedReadCapacityUnits", []))

    @jsii.member(jsii_name="metricConsumedWriteCapacityUnits")
    def metric_consumed_write_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConsumedWriteCapacityUnits", []))

    @jsii.member(jsii_name="metricIndexConsumedWriteUnitsMetric")
    def metric_index_consumed_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIndexConsumedWriteUnitsMetric", []))

    @jsii.member(jsii_name="metricProvisionedReadCapacityUnits")
    def metric_provisioned_read_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedReadCapacityUnits", []))

    @jsii.member(jsii_name="metricProvisionedWriteCapacityUnits")
    def metric_provisioned_write_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedWriteCapacityUnits", []))

    @jsii.member(jsii_name="metricThrottledIndexRequestCount")
    def metric_throttled_index_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledIndexRequestCount", []))

    @jsii.member(jsii_name="metricThrottledReadRequestCount")
    def metric_throttled_read_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledReadRequestCount", []))

    @jsii.member(jsii_name="metricThrottledWriteRequestCount")
    def metric_throttled_write_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledWriteRequestCount", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="table")
    def _table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, jsii.get(self, "table"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamoTableGlobalSecondaryIndexMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "global_secondary_index_name": "globalSecondaryIndexName",
        "table": "table",
    },
)
class DynamoTableGlobalSecondaryIndexMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        global_secondary_index_name: builtins.str,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param global_secondary_index_name: 
        :param table: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6efe7d6848c98376653b9f590f321bccfdcbb580069f7214295323136cc10e30)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument global_secondary_index_name", value=global_secondary_index_name, expected_type=type_hints["global_secondary_index_name"])
            check_type(argname="argument table", value=table, expected_type=type_hints["table"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "global_secondary_index_name": global_secondary_index_name,
            "table": table,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def global_secondary_index_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("global_secondary_index_name")
        assert result is not None, "Required property 'global_secondary_index_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''
        :stability: experimental
        '''
        result = self._values.get("table")
        assert result is not None, "Required property 'table' is missing"
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamoTableGlobalSecondaryIndexMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DynamoTableMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamoTableMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param table: (experimental) table to monitor.
        :param billing_mode: (experimental) table billing mode. Default: - best effort auto-detection or PROVISIONED as a fallback
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c9a2743a9ac4153126591046f987a71aecd551181ecc471d4813815b3983148c)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = DynamoTableMetricFactoryProps(
            table=table, billing_mode=billing_mode, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageSuccessfulRequestLatencyInMillis")
    def metric_average_successful_request_latency_in_millis(
        self,
        operation: _aws_cdk_aws_dynamodb_ceddda9d.Operation,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param operation: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8cbd6773e7f4f1a6a1e38362c0a35e7e413ea0d112b05605693a599a8dca25e)
            check_type(argname="argument operation", value=operation, expected_type=type_hints["operation"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageSuccessfulRequestLatencyInMillis", [operation]))

    @jsii.member(jsii_name="metricConsumedReadCapacityUnits")
    def metric_consumed_read_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConsumedReadCapacityUnits", []))

    @jsii.member(jsii_name="metricConsumedWriteCapacityUnits")
    def metric_consumed_write_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConsumedWriteCapacityUnits", []))

    @jsii.member(jsii_name="metricProvisionedReadCapacityUnits")
    def metric_provisioned_read_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedReadCapacityUnits", []))

    @jsii.member(jsii_name="metricProvisionedWriteCapacityUnits")
    def metric_provisioned_write_capacity_units(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedWriteCapacityUnits", []))

    @jsii.member(jsii_name="metricReadCapacityUtilizationPercentage")
    def metric_read_capacity_utilization_percentage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadCapacityUtilizationPercentage", []))

    @jsii.member(jsii_name="metricSearchAverageSuccessfulRequestLatencyInMillis")
    def metric_search_average_successful_request_latency_in_millis(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, jsii.invoke(self, "metricSearchAverageSuccessfulRequestLatencyInMillis", []))

    @jsii.member(jsii_name="metricSystemErrorsCount")
    def metric_system_errors_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) This represents the number of requests that resulted in a 500 (server error) error code.

        It summarizes across the basic CRUD operations:
        GetItem, BatchGetItem, Scan, Query, GetRecords, PutItem, DeleteItem, UpdateItem, BatchWriteItem

        It’s usually equal to zero.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSystemErrorsCount", []))

    @jsii.member(jsii_name="metricThrottledReadRequestCount")
    def metric_throttled_read_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledReadRequestCount", []))

    @jsii.member(jsii_name="metricThrottledWriteRequestCount")
    def metric_throttled_write_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledWriteRequestCount", []))

    @jsii.member(jsii_name="metricTimeToLiveDeletedItemCount")
    def metric_time_to_live_deleted_item_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTimeToLiveDeletedItemCount", []))

    @jsii.member(jsii_name="metricWriteCapacityUtilizationPercentage")
    def metric_write_capacity_utilization_percentage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteCapacityUtilizationPercentage", []))

    @builtins.property
    @jsii.member(jsii_name="table")
    def _table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, jsii.get(self, "table"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamoTableMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "table": "table",
        "billing_mode": "billingMode",
    },
)
class DynamoTableMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param table: (experimental) table to monitor.
        :param billing_mode: (experimental) table billing mode. Default: - best effort auto-detection or PROVISIONED as a fallback

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc8768b4396e945566f113089cc90526366e442f8102e472f4b974a1c233569f)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument table", value=table, expected_type=type_hints["table"])
            check_type(argname="argument billing_mode", value=billing_mode, expected_type=type_hints["billing_mode"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "table": table,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if billing_mode is not None:
            self._values["billing_mode"] = billing_mode

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''(experimental) table to monitor.

        :stability: experimental
        '''
        result = self._values.get("table")
        assert result is not None, "Required property 'table' is missing"
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, result)

    @builtins.property
    def billing_mode(
        self,
    ) -> typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode]:
        '''(experimental) table billing mode.

        :default: - best effort auto-detection or PROVISIONED as a fallback

        :stability: experimental
        '''
        result = self._values.get("billing_mode")
        return typing.cast(typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamoTableMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class EC2MetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.EC2MetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__218ed60f91855f35c191ca3ddc8cc11bf49a2e371e24d185520024e461f0e7d1)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = EC2MetricFactoryProps(
            auto_scaling_group=auto_scaling_group,
            instance_ids=instance_ids,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCpuUtilisationPercent")
    def metric_average_cpu_utilisation_percent(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''(experimental) The percentage of allocated EC2 compute units that are currently in use on the instance.

        This metric identifies the processing power required to run an application on a selected instance.
        Depending on the instance type, tools in your operating system can show a lower percentage than
        CloudWatch when the instance is not allocated a full processor core.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.invoke(self, "metricAverageCpuUtilisationPercent", []))

    @jsii.member(jsii_name="metricAverageDiskReadBytes")
    def metric_average_disk_read_bytes(
        self,
    ) -> typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''(experimental) Bytes read from all instance store volumes available to the instance.

        This metric is used to determine the volume of the data the application reads from the hard disk of the instance.
        This can be used to determine the speed of the application.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.invoke(self, "metricAverageDiskReadBytes", []))

    @jsii.member(jsii_name="metricAverageDiskReadOps")
    def metric_average_disk_read_ops(
        self,
    ) -> typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''(experimental) Completed read operations from all instance store volumes available to the instance in a specified period of time.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.invoke(self, "metricAverageDiskReadOps", []))

    @jsii.member(jsii_name="metricAverageDiskWriteBytes")
    def metric_average_disk_write_bytes(
        self,
    ) -> typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''(experimental) Bytes written to all instance store volumes available to the instance.

        This metric is used to determine the volume of the data the application writes onto the hard disk of the instance.
        This can be used to determine the speed of the application.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.invoke(self, "metricAverageDiskWriteBytes", []))

    @jsii.member(jsii_name="metricAverageDiskWriteOps")
    def metric_average_disk_write_ops(
        self,
    ) -> typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''(experimental) Completed write operations to all instance store volumes available to the instance in a specified period of time.

        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.invoke(self, "metricAverageDiskWriteOps", []))

    @jsii.member(jsii_name="metricAverageNetworkInRateBytes")
    def metric_average_network_in_rate_bytes(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''(experimental) The number of bytes received on all network interfaces by the instance.

        This metric identifies the volume of incoming network traffic to a single instance.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.invoke(self, "metricAverageNetworkInRateBytes", []))

    @jsii.member(jsii_name="metricAverageNetworkOutRateBytes")
    def metric_average_network_out_rate_bytes(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''(experimental) The number of bytes sent out on all network interfaces by the instance.

        This metric identifies the volume of outgoing network traffic from a single instance.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.invoke(self, "metricAverageNetworkOutRateBytes", []))

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def _strategy(self) -> "IEC2MetricFactoryStrategy":
        '''
        :stability: experimental
        '''
        return typing.cast("IEC2MetricFactoryStrategy", jsii.get(self, "strategy"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.EC2MetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "auto_scaling_group": "autoScalingGroup",
        "instance_ids": "instanceIds",
    },
)
class EC2MetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a218e7e1b45c349f734abce1661cd3508196a5031d9ecfdeca03659f8018740)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
            check_type(argname="argument instance_ids", value=instance_ids, expected_type=type_hints["instance_ids"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if auto_scaling_group is not None:
            self._values["auto_scaling_group"] = auto_scaling_group
        if instance_ids is not None:
            self._values["instance_ids"] = instance_ids

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_scaling_group(
        self,
    ) -> typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup]:
        '''(experimental) Auto-Scaling Group to monitor.

        :default: - no Auto-Scaling Group filter

        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        return typing.cast(typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup], result)

    @builtins.property
    def instance_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Selected IDs of EC2 instances to monitor.

        :default: - no instance filter

        :stability: experimental
        '''
        result = self._values.get("instance_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EC2MetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ElastiCacheAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ElastiCacheAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__484631e89adcece39fd4765fc1aa1c50ffe9b8df7ef544e96ecd015bad528bcf)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxEvictedItemsCountAlarm")
    def add_max_evicted_items_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxItemsCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1c298e54d8e007efd6bea77f5e962b99e3e116c5b89e297e301be4a724eedaa)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxEvictedItemsCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxItemsCountAlarm")
    def add_max_items_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxItemsCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed32a56a8bb5411960d315b45d0320490084a95b6aa77f38dda6b971827b5d01)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxItemsCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxUsedSwapMemoryAlarm")
    def add_max_used_swap_memory_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxUsedSwapMemoryThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83dba0afa895a26337988cfe24b4996c98fa706d24bbc8dbf321a0d8784ebac8)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxUsedSwapMemoryAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinFreeableMemoryAlarm")
    def add_min_freeable_memory_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MinFreeableMemoryThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__381c5847b0669e07118eeabc12a039a832904d5483ef4530899da4adc76f8be4)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinFreeableMemoryAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class ElastiCacheClusterMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ElastiCacheClusterMetricFactory",
):
    '''
    :see: https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/CacheMetrics.html
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        cluster_id: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param cluster_id: (experimental) Cluster to monitor. Default: - monitor all clusters
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d082882f88bf56e0fa8f757ead3c858ad46b6419ec4c2ad314623a3cdd6ab118)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = ElastiCacheClusterMetricFactoryProps(
            cluster_id=cluster_id, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCachedItemsSizeInBytes")
    def metric_average_cached_items_size_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageCachedItemsSizeInBytes", []))

    @jsii.member(jsii_name="metricAverageConnections")
    def metric_average_connections(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageConnections", []))

    @jsii.member(jsii_name="metricAverageFreeableMemoryInBytes")
    def metric_average_freeable_memory_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageFreeableMemoryInBytes", []))

    @jsii.member(jsii_name="metricAverageSwapUsageInBytes")
    def metric_average_swap_usage_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageSwapUsageInBytes", []))

    @jsii.member(jsii_name="metricAverageUnusedMemoryInBytes")
    def metric_average_unused_memory_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageUnusedMemoryInBytes", []))

    @jsii.member(jsii_name="metricEvictions")
    def metric_evictions(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricEvictions", []))

    @jsii.member(jsii_name="metricMaxCpuUtilizationInPercent")
    def metric_max_cpu_utilization_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxCpuUtilizationInPercent", []))

    @jsii.member(jsii_name="metricMaxItemCount")
    def metric_max_item_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxItemCount", []))

    @jsii.member(jsii_name="metricMaxRedisEngineCpuUtilizationInPercent")
    def metric_max_redis_engine_cpu_utilization_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Because Redis is single-threaded, you can use this metric to analyze the load of the Redis process itself.

        Note that you may want to monitor both Engine CPU Utilization as well as CPU Utilization as background
        processes can take up a significant portion of the CPU workload. This is especially important for
        hosts with 2 vCPUs or less.

        :see: https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/CacheMetrics.Redis.html
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxRedisEngineCpuUtilizationInPercent", []))

    @jsii.member(jsii_name="metricNetworkBytesIn")
    def metric_network_bytes_in(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNetworkBytesIn", []))

    @jsii.member(jsii_name="metricNetworkBytesOut")
    def metric_network_bytes_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNetworkBytesOut", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ElastiCacheClusterMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "cluster_id": "clusterId"},
)
class ElastiCacheClusterMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster_id: (experimental) Cluster to monitor. Default: - monitor all clusters

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__68b3e75615fe2c1f005943c7ee6fa7432e05212e072fc87dc84dbfaf4b37d5fe)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if cluster_id is not None:
            self._values["cluster_id"] = cluster_id

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) Cluster to monitor.

        :default: - monitor all clusters

        :stability: experimental
        '''
        result = self._values.get("cluster_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ElastiCacheClusterMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.ElastiCacheClusterType")
class ElastiCacheClusterType(enum.Enum):
    '''
    :stability: experimental
    '''

    MEMCACHED = "MEMCACHED"
    '''
    :stability: experimental
    '''
    REDIS = "REDIS"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.ElasticsearchClusterStatus")
class ElasticsearchClusterStatus(enum.Enum):
    '''
    :stability: experimental
    '''

    RED = "RED"
    '''
    :stability: experimental
    '''
    YELLOW = "YELLOW"
    '''
    :stability: experimental
    '''


class ErrorAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ErrorAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b798d9b29818feccf7fb6b758c97f3d35072783ebf9f53c564d96d8e185aae63)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addErrorCountAlarm")
    def add_error_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        error_type: "ErrorType",
        props: typing.Union["ErrorCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param error_type: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfb7988e55977febfb96841b2dec4564ac02cb112410697ede137c527552a84d)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument error_type", value=error_type, expected_type=type_hints["error_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addErrorCountAlarm", [metric, error_type, props, disambiguator]))

    @jsii.member(jsii_name="addErrorRateAlarm")
    def add_error_rate_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        error_type: "ErrorType",
        props: typing.Union["ErrorRateThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param error_type: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3af36fc1c41feee2b22cbf398a88e95d1b12224804adc48d5b0cfcac3e032eb8)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument error_type", value=error_type, expected_type=type_hints["error_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addErrorRateAlarm", [metric, error_type, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ErrorCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_error_count": "maxErrorCount",
    },
)
class ErrorCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_error_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_error_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7936765a6e7ab5b5f411259975f394820a7710e193cefbc38809b24074fb862)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_error_count", value=max_error_count, expected_type=type_hints["max_error_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_error_count": max_error_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_error_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_error_count")
        assert result is not None, "Required property 'max_error_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ErrorCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ErrorRateThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_error_rate": "maxErrorRate",
    },
)
class ErrorRateThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_error_rate: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_error_rate: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2c2fbac7029d34d09846a42268794092bcb930b46d3460d0efd55e42d5fd763)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_error_rate", value=max_error_rate, expected_type=type_hints["max_error_rate"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_error_rate": max_error_rate,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_error_rate(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_error_rate")
        assert result is not None, "Required property 'max_error_rate' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ErrorRateThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.ErrorType")
class ErrorType(enum.Enum):
    '''
    :stability: experimental
    '''

    FAULT = "FAULT"
    '''
    :stability: experimental
    '''
    ERROR = "ERROR"
    '''
    :stability: experimental
    '''
    SYSTEM_ERROR = "SYSTEM_ERROR"
    '''
    :stability: experimental
    '''
    USER_ERROR = "USER_ERROR"
    '''
    :stability: experimental
    '''
    FAILURE = "FAILURE"
    '''
    :stability: experimental
    '''
    ABORTED = "ABORTED"
    '''
    :stability: experimental
    '''
    THROTTLED = "THROTTLED"
    '''
    :stability: experimental
    '''
    TIMED_OUT = "TIMED_OUT"
    '''
    :stability: experimental
    '''
    READ_ERROR = "READ_ERROR"
    '''
    :stability: experimental
    '''
    WRITE_ERROR = "WRITE_ERROR"
    '''
    :stability: experimental
    '''
    EXPIRED = "EXPIRED"
    '''
    :stability: experimental
    '''
    KILLED = "KILLED"
    '''
    :stability: experimental
    '''
    BLOCKED = "BLOCKED"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FirehoseStreamLimitThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "safety_threshold_limit": "safetyThresholdLimit",
    },
)
class FirehoseStreamLimitThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        safety_threshold_limit: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param safety_threshold_limit: (experimental) Threshold value between [0.0, 1.0) for when the alarm should be triggered.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f17a785fe075a84bc01e9474022d125b8ff1bcc4072f2fd8bd4e83a5c4344de)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument safety_threshold_limit", value=safety_threshold_limit, expected_type=type_hints["safety_threshold_limit"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "safety_threshold_limit": safety_threshold_limit,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def safety_threshold_limit(self) -> jsii.Number:
        '''(experimental) Threshold value between [0.0, 1.0) for when the alarm should be triggered.

        :stability: experimental
        '''
        result = self._values.get("safety_threshold_limit")
        assert result is not None, "Required property 'safety_threshold_limit' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FirehoseStreamLimitThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.FluentBitFilterMetricTag")
class FluentBitFilterMetricTag(enum.Enum):
    '''
    :stability: experimental
    '''

    FILTER_EMIT_RECORDS = "FILTER_EMIT_RECORDS"
    '''
    :stability: experimental
    '''
    FILTER_DROP_RECORDS = "FILTER_DROP_RECORDS"
    '''
    :stability: experimental
    '''
    FILTER_ADD_RECORDS = "FILTER_ADD_RECORDS"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.FluentBitInputMetricTag")
class FluentBitInputMetricTag(enum.Enum):
    '''
    :stability: experimental
    '''

    INPUT_RECORDS = "INPUT_RECORDS"
    '''
    :stability: experimental
    '''


class FluentBitMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.FluentBitMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "MonitoringScope",
        *,
        namespace: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param namespace: (experimental) Namespace that metrics will be emitted to. Default: metric factory default
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3765d3874fc2fc4405dc3b002bbb7bac24437ce2250616b353c1bb13eab8e0f1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = FluentBitMetricFactoryProps(
            namespace=namespace, account=account, region=region
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="filterMetrics")
    def filter_metrics(
        self,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :param log_group: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b2a8a21124f5085635a7b4c0036b0a849bf587e7a766ed12a950e08dd6c3dbfa)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.invoke(self, "filterMetrics", [log_group]))

    @jsii.member(jsii_name="inputMetrics")
    def input_metrics(
        self,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :param log_group: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2fb350e11b0c39f081eba61ca2f0a8a1cdc6b98da7aa235ee70270ec3e2ade21)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.invoke(self, "inputMetrics", [log_group]))

    @jsii.member(jsii_name="metricsWithoutWidgets")
    def metrics_without_widgets(
        self,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    ) -> None:
        '''
        :param log_group: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cabe6e69f921aa33f7a1b0a93d7d6e970689efb2733855cda7cf478608ae5c7e)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
        return typing.cast(None, jsii.invoke(self, "metricsWithoutWidgets", [log_group]))

    @jsii.member(jsii_name="outputMetrics")
    def output_metrics(
        self,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :param log_group: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a6d9fb498a44a3d834237badad56f0a25c4b1cf143735ccc0b2ed29cd861971)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.invoke(self, "outputMetrics", [log_group]))

    @jsii.member(jsii_name="storageMetrics")
    def storage_metrics(
        self,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :param log_group: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b49eb2ae5ea59d00284ae5354f9265a8ec45df1c9097e8c8c27cc5a55c65381b)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.invoke(self, "storageMetrics", [log_group]))

    @builtins.property
    @jsii.member(jsii_name="namespace")
    def _namespace(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "namespace"))

    @builtins.property
    @jsii.member(jsii_name="scope")
    def _scope(self) -> "MonitoringScope":
        '''
        :stability: experimental
        '''
        return typing.cast("MonitoringScope", jsii.get(self, "scope"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FluentBitMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "namespace": "namespace"},
)
class FluentBitMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        namespace: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param namespace: (experimental) Namespace that metrics will be emitted to. Default: metric factory default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0cf5ca8686eee80f35aed3cf0dc778eada5a2e340285ebc5c324bc5547636e8)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if namespace is not None:
            self._values["namespace"] = namespace

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Namespace that metrics will be emitted to.

        :default: metric factory default

        :stability: experimental
        '''
        result = self._values.get("namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FluentBitMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.FluentBitMetricsWithoutWidget")
class FluentBitMetricsWithoutWidget(enum.Enum):
    '''
    :stability: experimental
    '''

    INPUT_BYTES = "INPUT_BYTES"
    '''
    :stability: experimental
    '''
    OUTPUT_PROC_RECORDS = "OUTPUT_PROC_RECORDS"
    '''
    :stability: experimental
    '''
    OUTPUT_PROC_BYTES = "OUTPUT_PROC_BYTES"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.FluentBitOutputMetricTag")
class FluentBitOutputMetricTag(enum.Enum):
    '''
    :stability: experimental
    '''

    OUTPUT_RETRIES = "OUTPUT_RETRIES"
    '''
    :stability: experimental
    '''
    OUTPUT_RETRIES_FAILED = "OUTPUT_RETRIES_FAILED"
    '''
    :stability: experimental
    '''
    OUTPUT_ERRORS = "OUTPUT_ERRORS"
    '''
    :stability: experimental
    '''
    OUTPUT_DROPPED_RECORDS = "OUTPUT_DROPPED_RECORDS"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.FluentBitStorageMetricTag")
class FluentBitStorageMetricTag(enum.Enum):
    '''
    :stability: experimental
    '''

    TOTAL_CHUNKS = "TOTAL_CHUNKS"
    '''
    :stability: experimental
    '''
    MEM_CHUNKS = "MEM_CHUNKS"
    '''
    :stability: experimental
    '''
    FS_CHUNKS = "FS_CHUNKS"
    '''
    :stability: experimental
    '''
    FS_CHUNKS_UP = "FS_CHUNKS_UP"
    '''
    :stability: experimental
    '''
    FS_CHUNKS_DOWN = "FS_CHUNKS_DOWN"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FullRestartCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_full_restart_count": "maxFullRestartCount",
    },
)
class FullRestartCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_full_restart_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_full_restart_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__493576f7ee1b6c6a0a587e3b6d6f642f62893cf1e704ab683a55e1cd6cd9c401)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_full_restart_count", value=max_full_restart_count, expected_type=type_hints["max_full_restart_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_full_restart_count": max_full_restart_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_full_restart_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_full_restart_count")
        assert result is not None, "Required property 'max_full_restart_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FullRestartCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class GlueJobMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.GlueJobMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        job_name: builtins.str,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param job_name: 
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98bdc6dfc6686f05ae2b3a4d9df00b5cb97c123c609ebb25289f3f2c7bc93f9a)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = GlueJobMetricFactoryProps(
            job_name=job_name,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricActiveExecutorsAverage")
    def metric_active_executors_average(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActiveExecutorsAverage", []))

    @jsii.member(jsii_name="metricAverageExecutorCpuUsagePercentage")
    def metric_average_executor_cpu_usage_percentage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageExecutorCpuUsagePercentage", []))

    @jsii.member(jsii_name="metricAverageExecutorMemoryUsagePercentage")
    def metric_average_executor_memory_usage_percentage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageExecutorMemoryUsagePercentage", []))

    @jsii.member(jsii_name="metricCompletedStagesSum")
    def metric_completed_stages_sum(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCompletedStagesSum", []))

    @jsii.member(jsii_name="metricCompletedTasksSum")
    def metric_completed_tasks_sum(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCompletedTasksSum", []))

    @jsii.member(jsii_name="metricFailedTasksRate")
    def metric_failed_tasks_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFailedTasksRate", []))

    @jsii.member(jsii_name="metricFailedTasksSum")
    def metric_failed_tasks_sum(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFailedTasksSum", []))

    @jsii.member(jsii_name="metricKilledTasksRate")
    def metric_killed_tasks_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricKilledTasksRate", []))

    @jsii.member(jsii_name="metricKilledTasksSum")
    def metric_killed_tasks_sum(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricKilledTasksSum", []))

    @jsii.member(jsii_name="metricMaximumNeededExecutors")
    def metric_maximum_needed_executors(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaximumNeededExecutors", []))

    @jsii.member(jsii_name="metricTotalReadBytesFromS3")
    def metric_total_read_bytes_from_s3(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalReadBytesFromS3", []))

    @jsii.member(jsii_name="metricTotalWrittenBytesToS3")
    def metric_total_written_bytes_to_s3(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalWrittenBytesToS3", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> "RateComputationMethod":
        '''
        :stability: experimental
        '''
        return typing.cast("RateComputationMethod", jsii.get(self, "rateComputationMethod"))

    @builtins.property
    @jsii.member(jsii_name="typeCountDimensionsMap")
    def _type_count_dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "typeCountDimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.GlueJobMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "job_name": "jobName",
        "rate_computation_method": "rateComputationMethod",
    },
)
class GlueJobMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        job_name: builtins.str,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param job_name: 
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__18080bbf6d8f19ce6af6a910d75a1cf65d21fb8fce0b28bbef404905cea12f20)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "job_name": job_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("job_name")
        assert result is not None, "Required property 'job_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional["RateComputationMethod"]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional["RateComputationMethod"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GlueJobMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.GraphWidgetType")
class GraphWidgetType(enum.Enum):
    '''
    :stability: experimental
    '''

    BAR = "BAR"
    '''
    :stability: experimental
    '''
    LINE = "LINE"
    '''
    :stability: experimental
    '''
    PIE = "PIE"
    '''
    :stability: experimental
    '''
    SINGLE_VALUE = "SINGLE_VALUE"
    '''
    :stability: experimental
    '''
    STACKED_AREA = "STACKED_AREA"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.HeaderLevel")
class HeaderLevel(enum.Enum):
    '''
    :stability: experimental
    '''

    LARGE = "LARGE"
    '''
    :stability: experimental
    '''
    MEDIUM = "MEDIUM"
    '''
    :stability: experimental
    '''
    SMALL = "SMALL"
    '''
    :stability: experimental
    '''


class HeaderWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.TextWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.HeaderWidget",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        text: builtins.str,
        level: typing.Optional[HeaderLevel] = None,
        description: typing.Optional[builtins.str] = None,
        description_height: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param text: -
        :param level: -
        :param description: -
        :param description_height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8452da4f6b5065fd434c71097cb8ddadce18e3d2d091b38d595fc61a367a135d)
            check_type(argname="argument text", value=text, expected_type=type_hints["text"])
            check_type(argname="argument level", value=level, expected_type=type_hints["level"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument description_height", value=description_height, expected_type=type_hints["description_height"])
        jsii.create(self.__class__, self, [text, level, description, description_height])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HealthyTaskCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_healthy_tasks": "minHealthyTasks",
    },
)
class HealthyTaskCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_healthy_tasks: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_healthy_tasks: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2dad5289ff410a934ed29cb1b3b9f16cf8a9f9c081c52178409a559dcb9b51c2)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_healthy_tasks", value=min_healthy_tasks, expected_type=type_hints["min_healthy_tasks"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_healthy_tasks": min_healthy_tasks,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_healthy_tasks(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_healthy_tasks")
        assert result is not None, "Required property 'min_healthy_tasks' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HealthyTaskCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HealthyTaskPercentThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_healthy_task_percent": "minHealthyTaskPercent",
    },
)
class HealthyTaskPercentThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_healthy_task_percent: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_healthy_task_percent: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4213149b310c43260bfd27b4a2029af44f7441e4df21d00a6b56ab57a2672d1f)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_healthy_task_percent", value=min_healthy_task_percent, expected_type=type_hints["min_healthy_task_percent"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_healthy_task_percent": min_healthy_task_percent,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_healthy_task_percent(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_healthy_task_percent")
        assert result is not None, "Required property 'min_healthy_task_percent' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HealthyTaskPercentThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HighConnectionCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_connection_count": "maxConnectionCount",
    },
)
class HighConnectionCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_connection_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_connection_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd56bb0feb49df06a9e24215d9f30cc15793eaefb9f9669e919a0c26f4b259c1)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_connection_count", value=max_connection_count, expected_type=type_hints["max_connection_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_connection_count": max_connection_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_connection_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_connection_count")
        assert result is not None, "Required property 'max_connection_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HighConnectionCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HighMessagesPublishedThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_messages_published_count": "maxMessagesPublishedCount",
    },
)
class HighMessagesPublishedThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_messages_published_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_messages_published_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5d95e83cfa3ce3f79486413efe2394c6166782838522119af352612862b9c57)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_messages_published_count", value=max_messages_published_count, expected_type=type_hints["max_messages_published_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_messages_published_count": max_messages_published_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_messages_published_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_messages_published_count")
        assert result is not None, "Required property 'max_messages_published_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HighMessagesPublishedThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HighServerlessDatabaseCapacityThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_serverless_database_capacity": "maxServerlessDatabaseCapacity",
    },
)
class HighServerlessDatabaseCapacityThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_serverless_database_capacity: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_serverless_database_capacity: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b99e3034e8dc72ae2c72b88e869515639198c72c514ad3eb0b60feb3f93202b1)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_serverless_database_capacity", value=max_serverless_database_capacity, expected_type=type_hints["max_serverless_database_capacity"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_serverless_database_capacity": max_serverless_database_capacity,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_serverless_database_capacity(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_serverless_database_capacity")
        assert result is not None, "Required property 'max_serverless_database_capacity' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HighServerlessDatabaseCapacityThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.HighTpsThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_tps": "maxTps",
    },
)
class HighTpsThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional["IAlarmActionStrategy"] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_tps: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_tps: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__20ca105ebab6067ba02671047e2de412309ee2bb598dcbf9939b5f310e4e3b6c)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_tps", value=max_tps, expected_type=type_hints["max_tps"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_tps": max_tps,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional["IAlarmActionStrategy"]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional["IAlarmActionStrategy"], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional["IMetricAdjuster"]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional["IMetricAdjuster"], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_tps(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_tps")
        assert result is not None, "Required property 'max_tps' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HighTpsThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.interface(jsii_type="cdk-monitoring-constructs.IAlarmActionStrategy")
class IAlarmActionStrategy(typing_extensions.Protocol):
    '''(experimental) An object that appends actions to alarms.

    :stability: experimental
    '''

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: "IAlarmActionStrategy",
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...


class _IAlarmActionStrategyProxy:
    '''(experimental) An object that appends actions to alarms.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IAlarmActionStrategy"

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmActionStrategyProps(
            alarm=alarm,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarmActions", [props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAlarmActionStrategy).__jsii_proxy_class__ = lambda : _IAlarmActionStrategyProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IAlarmAnnotationStrategy")
class IAlarmAnnotationStrategy(typing_extensions.Protocol):
    '''(experimental) Helper class for creating annotations for alarms.

    :stability: experimental
    '''

    @jsii.member(jsii_name="createAnnotation")
    def create_annotation(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''(experimental) Creates annotation based on the metric and alarm properties.

        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...


class _IAlarmAnnotationStrategyProxy:
    '''(experimental) Helper class for creating annotations for alarms.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IAlarmAnnotationStrategy"

    @jsii.member(jsii_name="createAnnotation")
    def create_annotation(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''(experimental) Creates annotation based on the metric and alarm properties.

        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, jsii.invoke(self, "createAnnotation", [props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAlarmAnnotationStrategy).__jsii_proxy_class__ = lambda : _IAlarmAnnotationStrategyProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IAlarmConsumer")
class IAlarmConsumer(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="consume")
    def consume(
        self,
        alarms: typing.Sequence[typing.Union[AlarmWithAnnotation, typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''
        :param alarms: -

        :stability: experimental
        '''
        ...


class _IAlarmConsumerProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IAlarmConsumer"

    @jsii.member(jsii_name="consume")
    def consume(
        self,
        alarms: typing.Sequence[typing.Union[AlarmWithAnnotation, typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''
        :param alarms: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e5aab12c7cc961978dee44d87bdaa59c4d77175ccb3e36dce00e6602897b2b6)
            check_type(argname="argument alarms", value=alarms, expected_type=type_hints["alarms"])
        return typing.cast(None, jsii.invoke(self, "consume", [alarms]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAlarmConsumer).__jsii_proxy_class__ = lambda : _IAlarmConsumerProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IAlarmDedupeStringProcessor")
class IAlarmDedupeStringProcessor(typing_extensions.Protocol):
    '''(experimental) Strategy used to finalize dedupe string.

    :stability: experimental
    '''

    @jsii.member(jsii_name="processDedupeString")
    def process_dedupe_string(self, dedupe_string: builtins.str) -> builtins.str:
        '''(experimental) Process the dedupe string which was auto-generated.

        :param dedupe_string: -

        :return: final dedupe string

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="processDedupeStringOverride")
    def process_dedupe_string_override(
        self,
        dedupe_string: builtins.str,
    ) -> builtins.str:
        '''(experimental) Process the dedupe string which was specified by the user as an override.

        :param dedupe_string: -

        :return: final dedupe string

        :stability: experimental
        '''
        ...


class _IAlarmDedupeStringProcessorProxy:
    '''(experimental) Strategy used to finalize dedupe string.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IAlarmDedupeStringProcessor"

    @jsii.member(jsii_name="processDedupeString")
    def process_dedupe_string(self, dedupe_string: builtins.str) -> builtins.str:
        '''(experimental) Process the dedupe string which was auto-generated.

        :param dedupe_string: -

        :return: final dedupe string

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86a300e39af732a6f54f906c48c9bfbf5a02208a7bd1c89748ec3ceeb6163225)
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
        return typing.cast(builtins.str, jsii.invoke(self, "processDedupeString", [dedupe_string]))

    @jsii.member(jsii_name="processDedupeStringOverride")
    def process_dedupe_string_override(
        self,
        dedupe_string: builtins.str,
    ) -> builtins.str:
        '''(experimental) Process the dedupe string which was specified by the user as an override.

        :param dedupe_string: -

        :return: final dedupe string

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf8c6b1cf2894a44ed43da1a4dd392a5ddf232bf6911240b2bb6252ea271d67c)
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
        return typing.cast(builtins.str, jsii.invoke(self, "processDedupeStringOverride", [dedupe_string]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAlarmDedupeStringProcessor).__jsii_proxy_class__ = lambda : _IAlarmDedupeStringProcessorProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IAlarmNamingStrategy")
class IAlarmNamingStrategy(typing_extensions.Protocol):
    '''(experimental) Strategy used to name alarms, their widgets, and their dedupe strings.

    :stability: experimental
    '''

    @jsii.member(jsii_name="getDedupeString")
    def get_dedupe_string(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[builtins.str]:
        '''(experimental) How to generate the deduplication string for an alarm.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="getName")
    def get_name(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) How to generate the name of an alarm.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="getWidgetLabel")
    def get_widget_label(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) How to generate the label for the alarm displayed on a widget.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...


class _IAlarmNamingStrategyProxy:
    '''(experimental) Strategy used to name alarms, their widgets, and their dedupe strings.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IAlarmNamingStrategy"

    @jsii.member(jsii_name="getDedupeString")
    def get_dedupe_string(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[builtins.str]:
        '''(experimental) How to generate the deduplication string for an alarm.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getDedupeString", [props]))

    @jsii.member(jsii_name="getName")
    def get_name(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) How to generate the name of an alarm.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(builtins.str, jsii.invoke(self, "getName", [props]))

    @jsii.member(jsii_name="getWidgetLabel")
    def get_widget_label(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) How to generate the label for the alarm displayed on a widget.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(builtins.str, jsii.invoke(self, "getWidgetLabel", [props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAlarmNamingStrategy).__jsii_proxy_class__ = lambda : _IAlarmNamingStrategyProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IDashboardFactory")
class IDashboardFactory(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="addSegment")
    def add_segment(self, props: "IDashboardFactoryProps") -> None:
        '''
        :param props: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createdAlarmDashboard")
    def created_alarm_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createdDashboard")
    def created_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createdSummaryDashboard")
    def created_summary_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        ...


class _IDashboardFactoryProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IDashboardFactory"

    @jsii.member(jsii_name="addSegment")
    def add_segment(self, props: "IDashboardFactoryProps") -> None:
        '''
        :param props: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14f69a2fd3762c4e28115f4947a4ee18d1a794405c07e6329122fa01de805c99)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(None, jsii.invoke(self, "addSegment", [props]))

    @jsii.member(jsii_name="createdAlarmDashboard")
    def created_alarm_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdAlarmDashboard", []))

    @jsii.member(jsii_name="createdDashboard")
    def created_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdDashboard", []))

    @jsii.member(jsii_name="createdSummaryDashboard")
    def created_summary_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdSummaryDashboard", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDashboardFactory).__jsii_proxy_class__ = lambda : _IDashboardFactoryProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IDashboardFactoryProps")
class IDashboardFactoryProps(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="segment")
    def segment(self) -> "IDashboardSegment":
        '''(experimental) Segment to be placed on the dashboard.

        :stability: experimental
        '''
        ...

    @segment.setter
    def segment(self, value: "IDashboardSegment") -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="overrideProps")
    def override_props(self) -> typing.Optional["MonitoringDashboardsOverrideProps"]:
        '''(experimental) Dashboard placement override props.

        :default: - all default

        :stability: experimental
        '''
        ...

    @override_props.setter
    def override_props(
        self,
        value: typing.Optional["MonitoringDashboardsOverrideProps"],
    ) -> None:
        ...


class _IDashboardFactoryPropsProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IDashboardFactoryProps"

    @builtins.property
    @jsii.member(jsii_name="segment")
    def segment(self) -> "IDashboardSegment":
        '''(experimental) Segment to be placed on the dashboard.

        :stability: experimental
        '''
        return typing.cast("IDashboardSegment", jsii.get(self, "segment"))

    @segment.setter
    def segment(self, value: "IDashboardSegment") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e2d7801562ca386fb22fe1b52137d1310f9ae05b4f775a5d81c2c633ab151d4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "segment", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="overrideProps")
    def override_props(self) -> typing.Optional["MonitoringDashboardsOverrideProps"]:
        '''(experimental) Dashboard placement override props.

        :default: - all default

        :stability: experimental
        '''
        return typing.cast(typing.Optional["MonitoringDashboardsOverrideProps"], jsii.get(self, "overrideProps"))

    @override_props.setter
    def override_props(
        self,
        value: typing.Optional["MonitoringDashboardsOverrideProps"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__92068ccf45f20a97a903799d5f4ced73cc46987fdbd0fa577d0f059be6b6a210)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "overrideProps", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDashboardFactoryProps).__jsii_proxy_class__ = lambda : _IDashboardFactoryPropsProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IDashboardSegment")
class IDashboardSegment(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="alarmWidgets")
    def alarm_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for all alarms.

        These should go to the runbook or service dashboard.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the summary.

        These should go to the team OPS dashboard.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns all widgets.

        These should go to the detailed service dashboard.

        :stability: experimental
        '''
        ...


class _IDashboardSegmentProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IDashboardSegment"

    @jsii.member(jsii_name="alarmWidgets")
    def alarm_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for all alarms.

        These should go to the runbook or service dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "alarmWidgets", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the summary.

        These should go to the team OPS dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns all widgets.

        These should go to the detailed service dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDashboardSegment).__jsii_proxy_class__ = lambda : _IDashboardSegmentProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IDynamicDashboardFactory")
class IDynamicDashboardFactory(typing_extensions.Protocol):
    '''(experimental) This dashboard factory interface provides for dynamic dashboard generation through IDynamicDashboard segments which will return different content depending on the dashboard type.

    :stability: experimental
    '''

    @jsii.member(jsii_name="addDynamicSegment")
    def add_dynamic_segment(self, segment: "IDynamicDashboardSegment") -> None:
        '''(experimental) Adds a dynamic dashboard segment.

        :param segment: IDynamicDashboardSegment.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="getDashboard")
    def get_dashboard(
        self,
        type: builtins.str,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''(experimental) Gets the dashboard for the requested dashboard type.

        :param type: -

        :stability: experimental
        '''
        ...


class _IDynamicDashboardFactoryProxy:
    '''(experimental) This dashboard factory interface provides for dynamic dashboard generation through IDynamicDashboard segments which will return different content depending on the dashboard type.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IDynamicDashboardFactory"

    @jsii.member(jsii_name="addDynamicSegment")
    def add_dynamic_segment(self, segment: "IDynamicDashboardSegment") -> None:
        '''(experimental) Adds a dynamic dashboard segment.

        :param segment: IDynamicDashboardSegment.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__715834be628205872aa4a68b265113a7893b966209c85399866f30b58fdf36a8)
            check_type(argname="argument segment", value=segment, expected_type=type_hints["segment"])
        return typing.cast(None, jsii.invoke(self, "addDynamicSegment", [segment]))

    @jsii.member(jsii_name="getDashboard")
    def get_dashboard(
        self,
        type: builtins.str,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''(experimental) Gets the dashboard for the requested dashboard type.

        :param type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2cbcb4b5ea45177c015f37a96e309eccf6d6f2d041c1661704031f69cc0222fb)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "getDashboard", [type]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDynamicDashboardFactory).__jsii_proxy_class__ = lambda : _IDynamicDashboardFactoryProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IDynamicDashboardSegment")
class IDynamicDashboardSegment(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="widgetsForDashboard")
    def widgets_for_dashboard(
        self,
        name: builtins.str,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the requested dashboard type.

        :param name: name of dashboard for which widgets are generated.

        :stability: experimental
        '''
        ...


class _IDynamicDashboardSegmentProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IDynamicDashboardSegment"

    @jsii.member(jsii_name="widgetsForDashboard")
    def widgets_for_dashboard(
        self,
        name: builtins.str,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the requested dashboard type.

        :param name: name of dashboard for which widgets are generated.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4cdf844d61bda5925165058ea69f4cd34fb67b5a07541d38a9650c07b1cf28d3)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgetsForDashboard", [name]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDynamicDashboardSegment).__jsii_proxy_class__ = lambda : _IDynamicDashboardSegmentProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IEC2MetricFactoryStrategy")
class IEC2MetricFactoryStrategy(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="createMetrics")
    def create_metrics(
        self,
        metric_factory: "MetricFactory",
        metric_name: builtins.str,
        statistic: "MetricStatistic",
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :param metric_factory: -
        :param metric_name: -
        :param statistic: -
        :param region: -
        :param account: -

        :stability: experimental
        '''
        ...


class _IEC2MetricFactoryStrategyProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IEC2MetricFactoryStrategy"

    @jsii.member(jsii_name="createMetrics")
    def create_metrics(
        self,
        metric_factory: "MetricFactory",
        metric_name: builtins.str,
        statistic: "MetricStatistic",
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :param metric_factory: -
        :param metric_name: -
        :param statistic: -
        :param region: -
        :param account: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__756b8d4ba4e6bbd19b072835fb6ed0dcd7b4cf9bdc9b2977a9d845a19a9e4b78)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.invoke(self, "createMetrics", [metric_factory, metric_name, statistic, region, account]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IEC2MetricFactoryStrategy).__jsii_proxy_class__ = lambda : _IEC2MetricFactoryStrategyProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.ILoadBalancerMetricFactory")
class ILoadBalancerMetricFactory(typing_extensions.Protocol):
    '''(experimental) Common interface for load-balancer based service metric factories.

    :stability: experimental
    '''

    @jsii.member(jsii_name="metricActiveConnectionCount")
    def metric_active_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricHealthyTaskCount")
    def metric_healthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricHealthyTaskInPercent")
    def metric_healthy_task_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricNewConnectionCount")
    def metric_new_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricProcessedBytesMin")
    def metric_processed_bytes_min(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricUnhealthyRoutingCount")
    def metric_unhealthy_routing_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metricUnhealthyTaskCount")
    def metric_unhealthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        ...


class _ILoadBalancerMetricFactoryProxy:
    '''(experimental) Common interface for load-balancer based service metric factories.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.ILoadBalancerMetricFactory"

    @jsii.member(jsii_name="metricActiveConnectionCount")
    def metric_active_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActiveConnectionCount", []))

    @jsii.member(jsii_name="metricHealthyTaskCount")
    def metric_healthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskCount", []))

    @jsii.member(jsii_name="metricHealthyTaskInPercent")
    def metric_healthy_task_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskInPercent", []))

    @jsii.member(jsii_name="metricNewConnectionCount")
    def metric_new_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNewConnectionCount", []))

    @jsii.member(jsii_name="metricProcessedBytesMin")
    def metric_processed_bytes_min(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProcessedBytesMin", []))

    @jsii.member(jsii_name="metricUnhealthyRoutingCount")
    def metric_unhealthy_routing_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyRoutingCount", []))

    @jsii.member(jsii_name="metricUnhealthyTaskCount")
    def metric_unhealthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyTaskCount", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ILoadBalancerMetricFactory).__jsii_proxy_class__ = lambda : _ILoadBalancerMetricFactoryProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IMetricAdjuster")
class IMetricAdjuster(typing_extensions.Protocol):
    '''(experimental) Adjusts a metric before creating adding an alarm to it.

    :stability: experimental
    '''

    @jsii.member(jsii_name="adjustMetric")
    def adjust_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_scope: _constructs_77d1e7e8.Construct,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional["IMetricAdjuster"] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adjusts a metric.

        :param metric: The metric to adjust.
        :param alarm_scope: The alarm scope.
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :return: The adjusted metric.

        :stability: experimental
        '''
        ...


class _IMetricAdjusterProxy:
    '''(experimental) Adjusts a metric before creating adding an alarm to it.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IMetricAdjuster"

    @jsii.member(jsii_name="adjustMetric")
    def adjust_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_scope: _constructs_77d1e7e8.Construct,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adjusts a metric.

        :param metric: The metric to adjust.
        :param alarm_scope: The alarm scope.
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :return: The adjusted metric.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7b50fa294bfdf30d95b7378ba0618b45adb742252b80e5bc142f9008cb29386d)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument alarm_scope", value=alarm_scope, expected_type=type_hints["alarm_scope"])
        props = AddAlarmProps(
            alarm_description=alarm_description,
            alarm_name_suffix=alarm_name_suffix,
            comparison_operator=comparison_operator,
            threshold=threshold,
            treat_missing_data=treat_missing_data,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
        )

        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adjustMetric", [metric, alarm_scope, props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IMetricAdjuster).__jsii_proxy_class__ = lambda : _IMetricAdjusterProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IPublisherConsumer")
class IPublisherConsumer(typing_extensions.Protocol):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="consume")
    def consume(self, lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction) -> None:
        '''
        :param lambda_function: -

        :stability: experimental
        '''
        ...


class _IPublisherConsumerProxy:
    '''
    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IPublisherConsumer"

    @jsii.member(jsii_name="consume")
    def consume(self, lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction) -> None:
        '''
        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d4535512a7278de88237a352bc5944518abc94df103342b85b242a359bf289a)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "consume", [lambda_function]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPublisherConsumer).__jsii_proxy_class__ = lambda : _IPublisherConsumerProxy


@jsii.interface(jsii_type="cdk-monitoring-constructs.IWidgetFactory")
class IWidgetFactory(typing_extensions.Protocol):
    '''(experimental) Strategy for creating widgets.

    :stability: experimental
    '''

    @jsii.member(jsii_name="createAlarmDetailWidget")
    def create_alarm_detail_widget(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        alarm_description: builtins.str,
        alarm_label: builtins.str,
        alarm_name: builtins.str,
        alarm_name_suffix: builtins.str,
        alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IWidget:
        '''(experimental) Create widget representing an alarm detail.

        :param alarm: 
        :param alarm_description: 
        :param alarm_label: 
        :param alarm_name: 
        :param alarm_name_suffix: 
        :param alarm_rule_when_alarming: 
        :param alarm_rule_when_insufficient_data: 
        :param alarm_rule_when_ok: 
        :param annotation: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...


class _IWidgetFactoryProxy:
    '''(experimental) Strategy for creating widgets.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "cdk-monitoring-constructs.IWidgetFactory"

    @jsii.member(jsii_name="createAlarmDetailWidget")
    def create_alarm_detail_widget(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        alarm_description: builtins.str,
        alarm_label: builtins.str,
        alarm_name: builtins.str,
        alarm_name_suffix: builtins.str,
        alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IWidget:
        '''(experimental) Create widget representing an alarm detail.

        :param alarm: 
        :param alarm_description: 
        :param alarm_label: 
        :param alarm_name: 
        :param alarm_name_suffix: 
        :param alarm_rule_when_alarming: 
        :param alarm_rule_when_insufficient_data: 
        :param alarm_rule_when_ok: 
        :param annotation: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        alarm_ = AlarmWithAnnotation(
            alarm=alarm,
            alarm_description=alarm_description,
            alarm_label=alarm_label,
            alarm_name=alarm_name,
            alarm_name_suffix=alarm_name_suffix,
            alarm_rule_when_alarming=alarm_rule_when_alarming,
            alarm_rule_when_insufficient_data=alarm_rule_when_insufficient_data,
            alarm_rule_when_ok=alarm_rule_when_ok,
            annotation=annotation,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IWidget, jsii.invoke(self, "createAlarmDetailWidget", [alarm_]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IWidgetFactory).__jsii_proxy_class__ = lambda : _IWidgetFactoryProxy


class KeyValueTableWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.TextWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KeyValueTableWidget",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        data: typing.Sequence[typing.Mapping[typing.Any, typing.Any]],
    ) -> None:
        '''
        :param data: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a7180ef7acfbd0714c754e22af84bceab59958bf156c9be01ed62a90858cd35)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
        jsii.create(self.__class__, self, [data])


class KinesisAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6dd9be0e7dcdf4bbc79b28d19672877d10184a4150a2ba7c273ef5d624d7c0da)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addFirehoseStreamExceedSafetyThresholdAlarm")
    def add_firehose_stream_exceed_safety_threshold_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        metric_name: builtins.str,
        quota_name: builtins.str,
        props: typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param metric_name: -
        :param quota_name: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f27d500a1f668700c6dd5cc99d0b0b55535bed2d47ae9fd3296d6d3e8be4570)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
            check_type(argname="argument quota_name", value=quota_name, expected_type=type_hints["quota_name"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addFirehoseStreamExceedSafetyThresholdAlarm", [metric, metric_name, quota_name, props, disambiguator]))

    @jsii.member(jsii_name="addIteratorMaxAgeAlarm")
    def add_iterator_max_age_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxIteratorAgeThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4342315b54978991364a3d38136eb7222f5dfd2d658194e2e0fd19d21da7a830)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addIteratorMaxAgeAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addProvisionedReadThroughputExceededAlarm")
    def add_provisioned_read_throughput_exceeded_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["RecordsThrottledThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: builtins.str,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0632274c7089b3d1190d01ae17a0fc4f9a0224d609104c369a5a47c76f5d9a9b)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addProvisionedReadThroughputExceededAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addProvisionedWriteThroughputExceededAlarm")
    def add_provisioned_write_throughput_exceeded_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["RecordsThrottledThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: builtins.str,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0e6afbc022dd44a68c5f19767e5cde81611cf75cbefacc0bbb62caf8e2979070)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addProvisionedWriteThroughputExceededAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addPutRecordsFailedAlarm")
    def add_put_records_failed_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["RecordsFailedThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96e318f1ba95cf6f77db97209e23bc1f51692ee44cb6cdeb55cf5c21c500cc90)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addPutRecordsFailedAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addPutRecordsThrottledAlarm")
    def add_put_records_throttled_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["RecordsThrottledThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c42415b274d089b6cc85437de60f7671285ff979dfd3ce26904ffd19e2b3e52b)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addPutRecordsThrottledAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class KinesisDataAnalyticsAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__543b67aa776edb6ab9e9aed08d5cb0afce0593c03a60996f3771cb69574bbb50)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addDowntimeAlarm")
    def add_downtime_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["MaxDowntimeThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a03a966c633e54fc2818bd65be9611e209675d39d8ed71fc9a0ef3a92993a48b)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addDowntimeAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addFullRestartAlarm")
    def add_full_restart_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d3085719d63885435613ad4b3364f97c6adf2d557a5c29238b8d1ee5cddb1ef)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addFullRestartAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class KinesisDataAnalyticsMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsMetricFactory",
):
    '''
    :see: https://docs.aws.amazon.com/kinesisanalytics/latest/java/metrics-dimensions.html
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        application: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param application: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67e44fbc693d7e87af28a9dcf560c7ff620725d581d30878bb17f49b6d00f65d)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = KinesisDataAnalyticsMetricFactoryProps(
            application=application, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricCpuUtilizationPercent")
    def metric_cpu_utilization_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCpuUtilizationPercent", []))

    @jsii.member(jsii_name="metricDowntimeMs")
    def metric_downtime_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDowntimeMs", []))

    @jsii.member(jsii_name="metricFullRestartsCount")
    def metric_full_restarts_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFullRestartsCount", []))

    @jsii.member(jsii_name="metricHeapMemoryUtilizationPercent")
    def metric_heap_memory_utilization_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHeapMemoryUtilizationPercent", []))

    @jsii.member(jsii_name="metricKPUsCount")
    def metric_kp_us_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricKPUsCount", []))

    @jsii.member(jsii_name="metricLastCheckpointDurationMs")
    def metric_last_checkpoint_duration_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLastCheckpointDurationMs", []))

    @jsii.member(jsii_name="metricLastCheckpointSizeBytes")
    def metric_last_checkpoint_size_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLastCheckpointSizeBytes", []))

    @jsii.member(jsii_name="metricNumberOfFailedCheckpointsCount")
    def metric_number_of_failed_checkpoints_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNumberOfFailedCheckpointsCount", []))

    @jsii.member(jsii_name="metricOldGenerationGCCount")
    def metric_old_generation_gc_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricOldGenerationGCCount", []))

    @jsii.member(jsii_name="metricOldGenerationGCTimeMs")
    def metric_old_generation_gc_time_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricOldGenerationGCTimeMs", []))

    @jsii.member(jsii_name="metricUptimeMs")
    def metric_uptime_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUptimeMs", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "application": "application",
    },
)
class KinesisDataAnalyticsMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        application: builtins.str,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param application: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9610b685c3b1376783f98e7df27cacf2be380051dcd102d22a37e000c6b0c224)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument application", value=application, expected_type=type_hints["application"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application": application,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def application(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("application")
        assert result is not None, "Required property 'application' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataAnalyticsMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class KinesisDataStreamMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisDataStreamMetricFactory",
):
    '''
    :see: https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        stream_name: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param stream_name: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3918125a5d3905ec68626a9f418339a6c913c8d0a72084aa6e37f06a7e2da8b)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = KinesisDataStreamMetricFactoryProps(
            stream_name=stream_name, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricGetRecordsIteratorAgeMaxMs")
    def metric_get_records_iterator_age_max_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGetRecordsIteratorAgeMaxMs", []))

    @jsii.member(jsii_name="metricGetRecordsLatencyAverageMs")
    def metric_get_records_latency_average_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGetRecordsLatencyAverageMs", []))

    @jsii.member(jsii_name="metricGetRecordsSuccessCount")
    def metric_get_records_success_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGetRecordsSuccessCount", []))

    @jsii.member(jsii_name="metricGetRecordsSumBytes")
    def metric_get_records_sum_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGetRecordsSumBytes", []))

    @jsii.member(jsii_name="metricGetRecordsSumCount")
    def metric_get_records_sum_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGetRecordsSumCount", []))

    @jsii.member(jsii_name="metricIncomingDataSumBytes")
    def metric_incoming_data_sum_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingDataSumBytes", []))

    @jsii.member(jsii_name="metricIncomingDataSumCount")
    def metric_incoming_data_sum_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingDataSumCount", []))

    @jsii.member(jsii_name="metricPutRecordLatencyAverageMs")
    def metric_put_record_latency_average_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordLatencyAverageMs", []))

    @jsii.member(jsii_name="metricPutRecordsFailedRecordsCount")
    def metric_put_records_failed_records_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsFailedRecordsCount", []))

    @jsii.member(jsii_name="metricPutRecordsLatencyAverageMs")
    def metric_put_records_latency_average_ms(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsLatencyAverageMs", []))

    @jsii.member(jsii_name="metricPutRecordsSuccessCount")
    def metric_put_records_success_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsSuccessCount", []))

    @jsii.member(jsii_name="metricPutRecordsSuccessfulRecordsCount")
    def metric_put_records_successful_records_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsSuccessfulRecordsCount", []))

    @jsii.member(jsii_name="metricPutRecordsSumBytes")
    def metric_put_records_sum_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsSumBytes", []))

    @jsii.member(jsii_name="metricPutRecordsThrottledRecordsCount")
    def metric_put_records_throttled_records_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsThrottledRecordsCount", []))

    @jsii.member(jsii_name="metricPutRecordsTotalRecordsCount")
    def metric_put_records_total_records_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordsTotalRecordsCount", []))

    @jsii.member(jsii_name="metricPutRecordSuccessCount")
    def metric_put_record_success_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordSuccessCount", []))

    @jsii.member(jsii_name="metricPutRecordSumBytes")
    def metric_put_record_sum_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordSumBytes", []))

    @jsii.member(jsii_name="metricReadProvisionedThroughputExceeded")
    def metric_read_provisioned_throughput_exceeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadProvisionedThroughputExceeded", []))

    @jsii.member(jsii_name="metricReadProvisionedThroughputExceededPercent")
    def metric_read_provisioned_throughput_exceeded_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: please use ``metricReadProvisionedThroughputExceeded`` instead

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadProvisionedThroughputExceededPercent", []))

    @jsii.member(jsii_name="metricWriteProvisionedThroughputExceeded")
    def metric_write_provisioned_throughput_exceeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteProvisionedThroughputExceeded", []))

    @jsii.member(jsii_name="metricWriteProvisionedThroughputExceededPercent")
    def metric_write_provisioned_throughput_exceeded_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: please use ``metricWriteProvisionedThroughputExceeded`` instead

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteProvisionedThroughputExceededPercent", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataStreamMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "stream_name": "streamName",
    },
)
class KinesisDataStreamMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        stream_name: builtins.str,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param stream_name: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__991ebdd106f63e21f900788119601e6e9ce132434afa7b055c0de61a6bd12cfa)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument stream_name", value=stream_name, expected_type=type_hints["stream_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stream_name": stream_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def stream_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("stream_name")
        assert result is not None, "Required property 'stream_name' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataStreamMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class KinesisFirehoseMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisFirehoseMetricFactory",
):
    '''
    :see: https://docs.aws.amazon.com/firehose/latest/dev/monitoring-with-cloudwatch-metrics.html
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        delivery_stream_name: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param delivery_stream_name: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d4914092ddef90fcab0372f0a295ace80e27f997d3ccb4cfaa8c4f97727ce02)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = KinesisFirehoseMetricFactoryProps(
            delivery_stream_name=delivery_stream_name, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricBytesPerSecondLimit")
    def metric_bytes_per_second_limit(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricBytesPerSecondLimit", []))

    @jsii.member(jsii_name="metricFailedConversionCount")
    def metric_failed_conversion_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFailedConversionCount", []))

    @jsii.member(jsii_name="metricIncomingBytes")
    def metric_incoming_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingBytes", []))

    @jsii.member(jsii_name="metricIncomingBytesToLimitRate")
    def metric_incoming_bytes_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingBytesToLimitRate", []))

    @jsii.member(jsii_name="metricIncomingPutRequests")
    def metric_incoming_put_requests(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingPutRequests", []))

    @jsii.member(jsii_name="metricIncomingPutRequestsToLimitRate")
    def metric_incoming_put_requests_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingPutRequestsToLimitRate", []))

    @jsii.member(jsii_name="metricIncomingRecordCount")
    def metric_incoming_record_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingRecordCount", []))

    @jsii.member(jsii_name="metricIncomingRecordsToLimitRate")
    def metric_incoming_records_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingRecordsToLimitRate", []))

    @jsii.member(jsii_name="metricPutRecordBatchLatencyP90InMillis")
    def metric_put_record_batch_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordBatchLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricPutRecordLatencyP90InMillis")
    def metric_put_record_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRecordLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricPutRequestsPerSecondLimit")
    def metric_put_requests_per_second_limit(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricPutRequestsPerSecondLimit", []))

    @jsii.member(jsii_name="metricRecordsPerSecondLimit")
    def metric_records_per_second_limit(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRecordsPerSecondLimit", []))

    @jsii.member(jsii_name="metricSuccessfulConversionCount")
    def metric_successful_conversion_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSuccessfulConversionCount", []))

    @jsii.member(jsii_name="metricThrottledRecordCount")
    def metric_throttled_record_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottledRecordCount", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisFirehoseMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "delivery_stream_name": "deliveryStreamName",
    },
)
class KinesisFirehoseMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        delivery_stream_name: builtins.str,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param delivery_stream_name: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b4b05bc023bb7a539dd6ee30c6b1a0fedd0f85fb403852461b8860395416d2fe)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument delivery_stream_name", value=delivery_stream_name, expected_type=type_hints["delivery_stream_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "delivery_stream_name": delivery_stream_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def delivery_stream_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("delivery_stream_name")
        assert result is not None, "Required property 'delivery_stream_name' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisFirehoseMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LambdaFunctionEnhancedMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LambdaFunctionEnhancedMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param lambda_function: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c056daff833342aaad53d9c459eb320f2cdf8c0c47dd4547e32e773f9f265ed7)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = LambdaFunctionEnhancedMetricFactoryProps(
            lambda_function=lambda_function, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="enhancedMetricAvgCpuTotalTime")
    def enhanced_metric_avg_cpu_total_time(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricAvgCpuTotalTime", []))

    @jsii.member(jsii_name="enhancedMetricAvgMemoryUtilization")
    def enhanced_metric_avg_memory_utilization(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricAvgMemoryUtilization", []))

    @jsii.member(jsii_name="enhancedMetricFunctionCost")
    def enhanced_metric_function_cost(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricFunctionCost", []))

    @jsii.member(jsii_name="enhancedMetricMaxCpuTotalTime")
    def enhanced_metric_max_cpu_total_time(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricMaxCpuTotalTime", []))

    @jsii.member(jsii_name="enhancedMetricMaxMemoryUtilization")
    def enhanced_metric_max_memory_utilization(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricMaxMemoryUtilization", []))

    @jsii.member(jsii_name="enhancedMetricP90CpuTotalTime")
    def enhanced_metric_p90_cpu_total_time(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricP90CpuTotalTime", []))

    @jsii.member(jsii_name="enhancedMetricP90MemoryUtilization")
    def enhanced_metric_p90_memory_utilization(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "enhancedMetricP90MemoryUtilization", []))

    @builtins.property
    @jsii.member(jsii_name="lambdaFunction")
    def _lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, jsii.get(self, "lambdaFunction"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LambdaFunctionEnhancedMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "lambda_function": "lambdaFunction",
    },
)
class LambdaFunctionEnhancedMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param lambda_function: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e01c704e5bf022528d7de17fa670a27e0a1dabc0fd3232ac96b9f3ad59d89732)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "lambda_function": lambda_function,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_function")
        assert result is not None, "Required property 'lambda_function' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaFunctionEnhancedMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LambdaFunctionMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LambdaFunctionMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: "MetricFactory",
        *,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        lambda_insights_enabled: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param lambda_function: 
        :param fill_tps_with_zeroes: Default: - true
        :param lambda_insights_enabled: (experimental) Generate dashboard charts for Lambda Insights metrics. To enable Lambda Insights on your Lambda function, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html Default: - false
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb07c97b9ee2af4674cf713920412a7196dcdc445c3772d680cfe0e9f526bde3)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = LambdaFunctionMetricFactoryProps(
            lambda_function=lambda_function,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            lambda_insights_enabled=lambda_insights_enabled,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricConcurrentExecutions")
    def metric_concurrent_executions(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConcurrentExecutions", []))

    @jsii.member(jsii_name="metricFaultCount")
    def metric_fault_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFaultCount", []))

    @jsii.member(jsii_name="metricFaultRate")
    def metric_fault_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFaultRate", []))

    @jsii.member(jsii_name="metricInvocationCount")
    def metric_invocation_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationCount", []))

    @jsii.member(jsii_name="metricInvocationRate")
    def metric_invocation_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationRate", []))

    @jsii.member(jsii_name="metricLatencyInMillis")
    def metric_latency_in_millis(
        self,
        latency_type: "LatencyType",
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4443c4a6f306040bfe5c97d5c920c2a78529b4ccce8d61cee8c62b0ca58a1d0e)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricLatencyP50InMillis")
    def metric_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricLatencyP90InMillis")
    def metric_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricLatencyP99InMillis")
    def metric_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricMaxIteratorAgeInMillis")
    def metric_max_iterator_age_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxIteratorAgeInMillis", []))

    @jsii.member(jsii_name="metricMaxOffsetLagInNumberOfRecords")
    def metric_max_offset_lag_in_number_of_records(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxOffsetLagInNumberOfRecords", []))

    @jsii.member(jsii_name="metricProvisionedConcurrencySpilloverInvocations")
    def metric_provisioned_concurrency_spillover_invocations(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedConcurrencySpilloverInvocations", []))

    @jsii.member(jsii_name="metricProvisionedConcurrencySpilloverRate")
    def metric_provisioned_concurrency_spillover_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProvisionedConcurrencySpilloverRate", []))

    @jsii.member(jsii_name="metricThrottlesCount")
    def metric_throttles_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottlesCount", []))

    @jsii.member(jsii_name="metricThrottlesRate")
    def metric_throttles_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricThrottlesRate", []))

    @jsii.member(jsii_name="metricTps")
    def metric_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricInvocationRate} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTps", []))

    @builtins.property
    @jsii.member(jsii_name="fillTpsWithZeroes")
    def _fill_tps_with_zeroes(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "fillTpsWithZeroes"))

    @builtins.property
    @jsii.member(jsii_name="lambdaFunction")
    def _lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, jsii.get(self, "lambdaFunction"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> "RateComputationMethod":
        '''
        :stability: experimental
        '''
        return typing.cast("RateComputationMethod", jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LambdaFunctionMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "lambda_function": "lambdaFunction",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "lambda_insights_enabled": "lambdaInsightsEnabled",
        "rate_computation_method": "rateComputationMethod",
    },
)
class LambdaFunctionMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        lambda_insights_enabled: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param lambda_function: 
        :param fill_tps_with_zeroes: Default: - true
        :param lambda_insights_enabled: (experimental) Generate dashboard charts for Lambda Insights metrics. To enable Lambda Insights on your Lambda function, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html Default: - false
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0594831587b01e96a9eafee1a5db223a92bd8b13d8eca89a3a2240da120e160a)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument lambda_insights_enabled", value=lambda_insights_enabled, expected_type=type_hints["lambda_insights_enabled"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "lambda_function": lambda_function,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if lambda_insights_enabled is not None:
            self._values["lambda_insights_enabled"] = lambda_insights_enabled
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_function")
        assert result is not None, "Required property 'lambda_function' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def lambda_insights_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Generate dashboard charts for Lambda Insights metrics.

        To enable Lambda Insights on your Lambda function, see
        https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("lambda_insights_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional["RateComputationMethod"]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional["RateComputationMethod"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaFunctionMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LatencyAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LatencyAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d635d1b0799154804c26199390dad5e1059ba6ed13745ff11bcb549f983abb4)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addDurationAlarm")
    def add_duration_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        latency_type: "LatencyType",
        props: typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
        additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param latency_type: -
        :param props: -
        :param disambiguator: -
        :param additional_alarm_name_suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e8402fb9facc4bf7ebc33548dda4d5d5efb3d74e2c18c797d4dadad22f3a1417)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument additional_alarm_name_suffix", value=additional_alarm_name_suffix, expected_type=type_hints["additional_alarm_name_suffix"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addDurationAlarm", [metric, latency_type, props, disambiguator, additional_alarm_name_suffix]))

    @jsii.member(jsii_name="addIntegrationLatencyAlarm")
    def add_integration_latency_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        latency_type: "LatencyType",
        props: typing.Union["LatencyThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
        additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param latency_type: -
        :param props: -
        :param disambiguator: -
        :param additional_alarm_name_suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e7db01f529db91182babf32c97d70a3b465087cc27ca154ac06895f42e12165)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument additional_alarm_name_suffix", value=additional_alarm_name_suffix, expected_type=type_hints["additional_alarm_name_suffix"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addIntegrationLatencyAlarm", [metric, latency_type, props, disambiguator, additional_alarm_name_suffix]))

    @jsii.member(jsii_name="addJvmGarbageCollectionDurationAlarm")
    def add_jvm_garbage_collection_duration_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        latency_type: "LatencyType",
        props: typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
        additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param latency_type: -
        :param props: -
        :param disambiguator: -
        :param additional_alarm_name_suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c15e6011691ef74eb0e27592c4db2fd68c00b94dec1c22a6b43cd2b4e348b15)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument additional_alarm_name_suffix", value=additional_alarm_name_suffix, expected_type=type_hints["additional_alarm_name_suffix"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addJvmGarbageCollectionDurationAlarm", [metric, latency_type, props, disambiguator, additional_alarm_name_suffix]))

    @jsii.member(jsii_name="addLatencyAlarm")
    def add_latency_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        latency_type: "LatencyType",
        props: typing.Union["LatencyThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
        additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param latency_type: -
        :param props: -
        :param disambiguator: -
        :param additional_alarm_name_suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__65bde4b97f808d87d55d57785bfff3d5e0af30120a91131acb14e5423b62ff3a)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument additional_alarm_name_suffix", value=additional_alarm_name_suffix, expected_type=type_hints["additional_alarm_name_suffix"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addLatencyAlarm", [metric, latency_type, props, disambiguator, additional_alarm_name_suffix]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LatencyThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_latency": "maxLatency",
    },
)
class LatencyThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_latency: _aws_cdk_ceddda9d.Duration,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_latency: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0b22a4e1dbb3bedfea9b67bbe930f82069af29940f61f4bd27b3ed1719fff2d3)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_latency", value=max_latency, expected_type=type_hints["max_latency"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_latency": max_latency,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_latency(self) -> _aws_cdk_ceddda9d.Duration:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_latency")
        assert result is not None, "Required property 'max_latency' is missing"
        return typing.cast(_aws_cdk_ceddda9d.Duration, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LatencyThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.LatencyType")
class LatencyType(enum.Enum):
    '''
    :stability: experimental
    '''

    P50 = "P50"
    '''
    :stability: experimental
    '''
    P70 = "P70"
    '''
    :stability: experimental
    '''
    P90 = "P90"
    '''
    :stability: experimental
    '''
    P95 = "P95"
    '''
    :stability: experimental
    '''
    P99 = "P99"
    '''
    :stability: experimental
    '''
    P999 = "P999"
    '''
    :stability: experimental
    '''
    P9999 = "P9999"
    '''
    :stability: experimental
    '''
    P100 = "P100"
    '''
    :stability: experimental
    '''
    TM50 = "TM50"
    '''
    :stability: experimental
    '''
    TM70 = "TM70"
    '''
    :stability: experimental
    '''
    TM90 = "TM90"
    '''
    :stability: experimental
    '''
    TM95 = "TM95"
    '''
    :stability: experimental
    '''
    TM99 = "TM99"
    '''
    :stability: experimental
    '''
    TM999 = "TM999"
    '''
    :stability: experimental
    '''
    TM9999 = "TM9999"
    '''
    :stability: experimental
    '''
    TM95_TOP = "TM95_TOP"
    '''
    :stability: experimental
    '''
    TM99_TOP = "TM99_TOP"
    '''
    :stability: experimental
    '''
    TM999_TOP = "TM999_TOP"
    '''
    :stability: experimental
    '''
    TM9999_TOP = "TM9999_TOP"
    '''
    :stability: experimental
    '''
    AVERAGE = "AVERAGE"
    '''
    :stability: experimental
    '''
    MAX = "MAX"
    '''
    :stability: experimental
    '''


@jsii.enum(jsii_type="cdk-monitoring-constructs.LogLevel")
class LogLevel(enum.Enum):
    '''(experimental) Level of a given log.

    :stability: experimental
    '''

    ERROR = "ERROR"
    '''
    :stability: experimental
    '''
    CRITICAL = "CRITICAL"
    '''
    :stability: experimental
    '''
    FATAL = "FATAL"
    '''
    :stability: experimental
    '''


class LogLevelAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LogLevelAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd09c279db7b5399f505fd93fa6a43bb014b32e89d7fc5e436edd7b9abfe6694)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addLogCountAlarm")
    def add_log_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        log_level: LogLevel,
        props: typing.Union["LogLevelCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param log_level: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2de76ea3bb5a1ed963336c93199c27f04299f8d426087748a5066ed89f4dab94)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument log_level", value=log_level, expected_type=type_hints["log_level"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addLogCountAlarm", [metric, log_level, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LogLevelCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_log_count": "maxLogCount",
    },
)
class LogLevelCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_log_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_log_count: (experimental) Threshold for the number of logs to alarm on.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a734964a068eeff03df1d9d7e0385c2e22bfb83de84c30fdc0a3815cf4bd1ca)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_log_count", value=max_log_count, expected_type=type_hints["max_log_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_log_count": max_log_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_log_count(self) -> jsii.Number:
        '''(experimental) Threshold for the number of logs to alarm on.

        :stability: experimental
        '''
        result = self._values.get("max_log_count")
        assert result is not None, "Required property 'max_log_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LogLevelCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LowConnectionCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_connection_count": "minConnectionCount",
    },
)
class LowConnectionCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_connection_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_connection_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b7bdfb77e5e87ee7537a8b99d5783aa5de8929de5236f6d1a2c7abc496730581)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_connection_count", value=min_connection_count, expected_type=type_hints["min_connection_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_connection_count": min_connection_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_connection_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_connection_count")
        assert result is not None, "Required property 'min_connection_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LowConnectionCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LowMessagesPublishedThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_messages_published_count": "minMessagesPublishedCount",
    },
)
class LowMessagesPublishedThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_messages_published_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_messages_published_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ddbc4dd2acbb7bd0cc90993abe98b1f02aa9239a8d6ce6c9f857a9d6ab5807a)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_messages_published_count", value=min_messages_published_count, expected_type=type_hints["min_messages_published_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_messages_published_count": min_messages_published_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_messages_published_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_messages_published_count")
        assert result is not None, "Required property 'min_messages_published_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LowMessagesPublishedThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LowTpsThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_tps": "minTps",
    },
)
class LowTpsThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_tps: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_tps: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__15dc471f745ef3ae7c8ed37bb1f8ff889bdc9de117a145fe5ff7db6c793b4573)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_tps", value=min_tps, expected_type=type_hints["min_tps"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_tps": min_tps,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_tps(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_tps")
        assert result is not None, "Required property 'min_tps' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LowTpsThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxAgeThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_age_in_millis": "maxAgeInMillis",
    },
)
class MaxAgeThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_age_in_millis: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_age_in_millis: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eba07c131f24675f68a137a4ede435f0b00239e75adadfd3e42b7c1aa01b912a)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_age_in_millis", value=max_age_in_millis, expected_type=type_hints["max_age_in_millis"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_age_in_millis": max_age_in_millis,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_age_in_millis(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_age_in_millis")
        assert result is not None, "Required property 'max_age_in_millis' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxAgeThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxDowntimeThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_downtime_in_millis": "maxDowntimeInMillis",
    },
)
class MaxDowntimeThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_downtime_in_millis: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_downtime_in_millis: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b74d9265c1413488b86e752c79101fe405c6ca8a738be88a15dd5edc4705b1e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_downtime_in_millis", value=max_downtime_in_millis, expected_type=type_hints["max_downtime_in_millis"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_downtime_in_millis": max_downtime_in_millis,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_downtime_in_millis(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_downtime_in_millis")
        assert result is not None, "Required property 'max_downtime_in_millis' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxDowntimeThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxIncomingMessagesCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_incoming_messages_count": "maxIncomingMessagesCount",
    },
)
class MaxIncomingMessagesCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_incoming_messages_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_incoming_messages_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3bcc1bcb55ac8bb9d7d5339ba09dd551e9caf80696269e6af62618a80e42679c)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_incoming_messages_count", value=max_incoming_messages_count, expected_type=type_hints["max_incoming_messages_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_incoming_messages_count": max_incoming_messages_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_incoming_messages_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_incoming_messages_count")
        assert result is not None, "Required property 'max_incoming_messages_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxIncomingMessagesCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxItemsCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_items_count": "maxItemsCount",
    },
)
class MaxItemsCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_items_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_items_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__343d60cc15d8f92e4f7df5b3fdfa45d31295f776c7078a65bc33ccb2cbc022de)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_items_count", value=max_items_count, expected_type=type_hints["max_items_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_items_count": max_items_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_items_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_items_count")
        assert result is not None, "Required property 'max_items_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxItemsCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxIteratorAgeThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_age_in_millis": "maxAgeInMillis",
    },
)
class MaxIteratorAgeThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_age_in_millis: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_age_in_millis: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__177fcea6eb23cd9ca7eecc32eed547e9a2e6eaa23c842f42d41f29a441effd1c)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_age_in_millis", value=max_age_in_millis, expected_type=type_hints["max_age_in_millis"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_age_in_millis": max_age_in_millis,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_age_in_millis(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_age_in_millis")
        assert result is not None, "Required property 'max_age_in_millis' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxIteratorAgeThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxMessageAgeThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_age_in_seconds": "maxAgeInSeconds",
    },
)
class MaxMessageAgeThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_age_in_seconds: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_age_in_seconds: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3bab2c0fc702f4f6250ce5fe55e971cafeacc720a174484b6cc9044940759fb1)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_age_in_seconds", value=max_age_in_seconds, expected_type=type_hints["max_age_in_seconds"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_age_in_seconds": max_age_in_seconds,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_age_in_seconds(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_age_in_seconds")
        assert result is not None, "Required property 'max_age_in_seconds' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxMessageAgeThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxMessageCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_message_count": "maxMessageCount",
    },
)
class MaxMessageCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_message_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_message_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a95b1b927453c4b8ab8a15dcadd6fc1aad50d0bdec761b4a49050d1e4fe4d75)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_message_count", value=max_message_count, expected_type=type_hints["max_message_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_message_count": max_message_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_message_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_message_count")
        assert result is not None, "Required property 'max_message_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxMessageCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxOffsetLagThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_offset_lag": "maxOffsetLag",
    },
)
class MaxOffsetLagThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_offset_lag: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_offset_lag: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ac019cbf25c3e8f4bc59bff3fa347fb614b1f68872e5baf8b2d5b07225a2c1c9)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_offset_lag", value=max_offset_lag, expected_type=type_hints["max_offset_lag"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_offset_lag": max_offset_lag,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_offset_lag(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_offset_lag")
        assert result is not None, "Required property 'max_offset_lag' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxOffsetLagThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxSecretCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_secret_count": "maxSecretCount",
    },
)
class MaxSecretCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_secret_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_secret_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d94c289428e4b3812e4c81eac89eb86383cc625051fde3f08f8c0b25bb23abe8)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_secret_count", value=max_secret_count, expected_type=type_hints["max_secret_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_secret_count": max_secret_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_secret_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_secret_count")
        assert result is not None, "Required property 'max_secret_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxSecretCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxTimeToDrainThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_time_to_drain": "maxTimeToDrain",
    },
)
class MaxTimeToDrainThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_time_to_drain: _aws_cdk_ceddda9d.Duration,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_time_to_drain: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3e96b576e53a2b7d3d911126d7aa02542f7bf9e2509d8044c6c0310beca2d815)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_time_to_drain", value=max_time_to_drain, expected_type=type_hints["max_time_to_drain"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_time_to_drain": max_time_to_drain,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_time_to_drain(self) -> _aws_cdk_ceddda9d.Duration:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_time_to_drain")
        assert result is not None, "Required property 'max_time_to_drain' is missing"
        return typing.cast(_aws_cdk_ceddda9d.Duration, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxTimeToDrainThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxUsageCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_count": "maxCount",
    },
)
class MaxUsageCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83399255159d530e9a79076bbc9dbe83b8914317540586af8190fd23568165b0)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_count", value=max_count, expected_type=type_hints["max_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_count": max_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_count")
        assert result is not None, "Required property 'max_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxUsageCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MaxUsedSwapMemoryThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_used_swap_memory_in_bytes": "maxUsedSwapMemoryInBytes",
    },
)
class MaxUsedSwapMemoryThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_used_swap_memory_in_bytes: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_used_swap_memory_in_bytes: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07531ae0edbbf677c563d7b56977689f9f7c8db7bf304d036c011d6a2c0f2593)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_used_swap_memory_in_bytes", value=max_used_swap_memory_in_bytes, expected_type=type_hints["max_used_swap_memory_in_bytes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_used_swap_memory_in_bytes": max_used_swap_memory_in_bytes,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_used_swap_memory_in_bytes(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_used_swap_memory_in_bytes")
        assert result is not None, "Required property 'max_used_swap_memory_in_bytes' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MaxUsedSwapMemoryThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MetricFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        props: typing.Optional[typing.Union["MetricFactoryProps", typing.Dict[builtins.str, typing.Any]]] = None,
        scope: typing.Optional[_constructs_77d1e7e8.Construct] = None,
    ) -> None:
        '''
        :param props: -
        :param scope: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87020e89dff6230d8f03e63fe678970d6847e16fc1bfcc16b459a216e70d78de)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        jsii.create(self.__class__, self, [props, scope])

    @jsii.member(jsii_name="adaptMetric")
    def adapt_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.

        Might modify namespace and metric period.

        :param metric: metric to be adapted.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a0f2cac0b013b53e24ca2cf36ddb1260dc1a50a173dda5ff24a8242197fbcc68)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adaptMetric", [metric]))

    @jsii.member(jsii_name="adaptMetricPreservingPeriod")
    def adapt_metric_preserving_period(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.

        Might modify namespace. Preserves metric period.

        :param metric: metric to be adapted.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__88cf78f9ec04a85a3b73174430c3d60ba8c1e9f0ccd0f08c25436de573b2d227)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adaptMetricPreservingPeriod", [metric]))

    @jsii.member(jsii_name="addAdditionalDimensions")
    def add_additional_dimensions(
        self,
        target: typing.Mapping[builtins.str, builtins.str],
        additional_dimensions: typing.Mapping[builtins.str, builtins.str],
    ) -> None:
        '''(experimental) Merges the given additional dimensions to the given target dimension hash.

        All existing dimensions with the same key are replaced.

        :param target: target dimension hash to update.
        :param additional_dimensions: additional dimensions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__866bac41d86ba9c0aa7c1bea0d225f31040de1664e562c08e20e996b03927f7c)
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
            check_type(argname="argument additional_dimensions", value=additional_dimensions, expected_type=type_hints["additional_dimensions"])
        return typing.cast(None, jsii.invoke(self, "addAdditionalDimensions", [target, additional_dimensions]))

    @jsii.member(jsii_name="createMetric")
    def create_metric(
        self,
        metric_name: builtins.str,
        statistic: "MetricStatistic",
        label: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        color: typing.Optional[builtins.str] = None,
        namespace: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Factory method that creates a metric.

        The metric properties will already be updated to comply with the global defaults.

        :param metric_name: metric name.
        :param statistic: aggregation statistic to use.
        :param label: metric label; if undefined, metric name is used by CloudWatch
        :param dimensions_map: additional dimensions to be added.
        :param color: metric color; if undefined, uses a CloudWatch provided color (preferred)
        :param namespace: specify a custom namespace; if undefined, uses the global default
        :param period: specify a custom period; if undefined, uses the global default
        :param region: specify a custom region; if undefined, uses the global default
        :param account: specify a custom account; if undefined, uses the global default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e65896875d1f2b1b8ef0d32fb7451ff3bd30f36b9e04659b8f05b8dc9bfdb81e)
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument dimensions_map", value=dimensions_map, expected_type=type_hints["dimensions_map"])
            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "createMetric", [metric_name, statistic, label, dimensions_map, color, namespace, period, region, account]))

    @jsii.member(jsii_name="createMetricAnomalyDetection")
    def create_metric_anomaly_detection(
        self,
        metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
        stdev: jsii.Number,
        label: builtins.str,
        color: typing.Optional[builtins.str] = None,
        expression_id: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Factory method that creates anomaly detection on a metric.

        Anomaly occurs whenever a metric value falls outside of a precomputed range of predicted values.
        The detection does not need any setup. The model will start learning automatically and should be ready in a few minutes.
        Usually, the anomaly detection is paired with an alarm.

        :param metric: metric to detect anomaly detection of.
        :param stdev: standard deviation, basically the tolerance / band thickness.
        :param label: metric label (required, as there is no reasonable default).
        :param color: metric color; if undefined, uses a CloudWatch provided color (preferred)
        :param expression_id: expression ID of the metric; uses ``m1`` if undefined
        :param period: specify a custom period; if undefined, uses the global default
        :param region: specify a custom region; if undefined, uses the global default
        :param account: specify a custom account; if undefined, uses the global default

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Anomaly_Detection.html
        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a446bf6dcc8a77c636c0d2f5a970ea8b8af73f22c143bd75bad8158b7361c7b6)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument stdev", value=stdev, expected_type=type_hints["stdev"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
            check_type(argname="argument expression_id", value=expression_id, expected_type=type_hints["expression_id"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "createMetricAnomalyDetection", [metric, stdev, label, color, expression_id, period, region, account]))

    @jsii.member(jsii_name="createMetricMath")
    def create_metric_math(
        self,
        expression: builtins.str,
        using_metrics: typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        label: builtins.str,
        color: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Factory method that creates a metric math expression.

        The metric properties will already be updated to comply with the global defaults.

        :param expression: CloudWatch metric math expression (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html).
        :param using_metrics: map of metrics, where keys are expression IDs (used in the expression) and values are metrics.
        :param label: metric label (required, as there is no reasonable default).
        :param color: metric color; if undefined, uses a CloudWatch provided color (preferred)
        :param period: specify a custom period; if undefined, uses the global default
        :param region: specify a custom region; if undefined, uses the global default
        :param account: specify a custom account; if undefined, uses the global default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6330b44fe9753bdb63f2de387682ea84cac9f6427f48173cafafa49ee1abe91f)
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
            check_type(argname="argument using_metrics", value=using_metrics, expected_type=type_hints["using_metrics"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "createMetricMath", [expression, using_metrics, label, color, period, region, account]))

    @jsii.member(jsii_name="createMetricSearch")
    def create_metric_search(
        self,
        query: builtins.str,
        dimensions_map: typing.Mapping[builtins.str, builtins.str],
        statistic: "MetricStatistic",
        namespace: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression:
        '''(experimental) Factory method that creates a metric search query.

        The metric properties will already be updated to comply with the global defaults.
        If you want to match "any value" of a specific dimension, please use ``undefined`` value representation in your consumer language.
        (For example, ``undefined as any as string`` in TypeScript, due to JSII typing quirks.)

        :param query: metric search query (the same as the search query prompt in CloudWatch AWS Console), it might also be empty.
        :param dimensions_map: dimensions, further narrowing the search results; use ``undefined`` if you want to represent "any value" (in TS: ``undefined as any as string``)
        :param statistic: aggregation statistic to use.
        :param namespace: specify a custom namespace; if undefined, uses the global default
        :param label: specify custom label for search metrics; default is " " as it cannot be empty string
        :param period: specify a custom period; if undefined, uses the global default
        :param region: specify a custom region; if undefined, uses the global default
        :param account: specify a custom account; if undefined, uses the global default

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ea2fc908d5272c75f0c20a5a4e593bf8ec782ad3db61b3185f6a6dc73a55b8d)
            check_type(argname="argument query", value=query, expected_type=type_hints["query"])
            check_type(argname="argument dimensions_map", value=dimensions_map, expected_type=type_hints["dimensions_map"])
            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, jsii.invoke(self, "createMetricSearch", [query, dimensions_map, statistic, namespace, label, period, region, account]))

    @jsii.member(jsii_name="divideMetric")
    def divide_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        divisor: jsii.Number,
        label: builtins.str,
        expression_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Creates a metric math expression that divides the given metric by given coefficient.

        Does nothing if the divisor is one. Preserves the metric period.

        :param metric: metric to multiply.
        :param divisor: divisor (must be > 1).
        :param label: expression label.
        :param expression_id: expression ID of the metric; uses ``m1`` if undefined

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aaa0bbf1e29ce34520197ee75922fd010882112aeadac0330c1d49d567a03e37)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument divisor", value=divisor, expected_type=type_hints["divisor"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument expression_id", value=expression_id, expected_type=type_hints["expression_id"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "divideMetric", [metric, divisor, label, expression_id]))

    @jsii.member(jsii_name="getNamespaceWithFallback")
    def get_namespace_with_fallback(
        self,
        value: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Returns the given namespace (if defined) or the global namespace as a fallback.

        If there is no namespace to fallback to (neither the custom or the default one), it will fail.

        :param value: custom namespace.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4af36769d31c793c646f96ef988415069be99c6d31e9c3e6a73f8394b2220b67)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast(builtins.str, jsii.invoke(self, "getNamespaceWithFallback", [value]))

    @jsii.member(jsii_name="multiplyMetric")
    def multiply_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        multiplier: jsii.Number,
        label: builtins.str,
        expression_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Creates a metric math expression that multiplies the given metric by given coefficient.

        Does nothing if the multiplier is one. Preserves the metric period.

        :param metric: metric to multiply.
        :param multiplier: multiplier (must be > 1).
        :param label: expression label.
        :param expression_id: expression ID of the metric; uses ``m1`` if undefined

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ffb960f2d5315d4ffa5046d853b50470ffa4d31cccc2a58791f819a5ea0060be)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument multiplier", value=multiplier, expected_type=type_hints["multiplier"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument expression_id", value=expression_id, expected_type=type_hints["expression_id"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "multiplyMetric", [metric, multiplier, label, expression_id]))

    @jsii.member(jsii_name="sanitizeMetricExpressionIdSuffix")
    def sanitize_metric_expression_id_suffix(
        self,
        expression_id: builtins.str,
    ) -> builtins.str:
        '''(experimental) Helper method that helps to sanitize the given expression ID and removes all invalid characters.

        Valid expression ID regexp is the following: ^[a-z][a-zA-Z0-9_]*$
        As this is just to validate a suffix and not the whole ID, we do not have to verify the first lower case letter.

        :param expression_id: expression ID to sanitize.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e1d238382709ed89b963f3323acad1c91079640ec6215e318662ff0b4adf9d75)
            check_type(argname="argument expression_id", value=expression_id, expected_type=type_hints["expression_id"])
        return typing.cast(builtins.str, jsii.invoke(self, "sanitizeMetricExpressionIdSuffix", [expression_id]))

    @jsii.member(jsii_name="toRate")
    def to_rate(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        method: "RateComputationMethod",
        add_stats_to_label: typing.Optional[builtins.bool] = None,
        expression_id: typing.Optional[builtins.str] = None,
        fill_with_zeroes: typing.Optional[builtins.bool] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Creates a metric math expression that computes a rate from a regular metric.

        For example, it allows you to compute rate per second (TPS), per minute, or just an average of your transactions.

        :param metric: metric to calculate the rate from.
        :param method: rate computation method.
        :param add_stats_to_label: add detailed statistics (min, max, average) to the label.
        :param expression_id: expression ID of the metric; uses ``m1`` if undefined
        :param fill_with_zeroes: if TRUE, the final metric will be zero-filled (0 on no data); false if undefined

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6443e995125fc081fe2fe171583b9aa63a1911c17b96695ee0ce70edd047e70)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument method", value=method, expected_type=type_hints["method"])
            check_type(argname="argument add_stats_to_label", value=add_stats_to_label, expected_type=type_hints["add_stats_to_label"])
            check_type(argname="argument expression_id", value=expression_id, expected_type=type_hints["expression_id"])
            check_type(argname="argument fill_with_zeroes", value=fill_with_zeroes, expected_type=type_hints["fill_with_zeroes"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "toRate", [metric, method, add_stats_to_label, expression_id, fill_with_zeroes]))

    @builtins.property
    @jsii.member(jsii_name="globalDefaults")
    def _global_defaults(self) -> "MetricFactoryDefaults":
        '''
        :stability: experimental
        '''
        return typing.cast("MetricFactoryDefaults", jsii.get(self, "globalDefaults"))

    @builtins.property
    @jsii.member(jsii_name="scope")
    def _scope(self) -> typing.Optional[_constructs_77d1e7e8.Construct]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_constructs_77d1e7e8.Construct], jsii.get(self, "scope"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MetricFactoryDefaults",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "namespace": "namespace",
        "period": "period",
    },
)
class MetricFactoryDefaults(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        namespace: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''(experimental) These are the globals used for each metric, unless there is some kind of override.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param namespace: (experimental) Each metric exists in a namespace. AWS Services have their own namespace, but here you can specify your custom one.
        :param period: (experimental) Metric period. Default value is used if not defined. Default: - DefaultMetricPeriod

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__df57e062e7d88eb2f2865b70e82a9191fdb782bfe6268046c10bdec78789d4e1)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if namespace is not None:
            self._values["namespace"] = namespace
        if period is not None:
            self._values["period"] = period

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Each metric exists in a namespace.

        AWS Services have their own namespace, but here you can specify your custom one.

        :stability: experimental
        '''
        result = self._values.get("namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Metric period.

        Default value is used if not defined.

        :default: - DefaultMetricPeriod

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MetricFactoryDefaults(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MetricFactoryProps",
    jsii_struct_bases=[],
    name_mapping={"global_defaults": "globalDefaults"},
)
class MetricFactoryProps:
    def __init__(
        self,
        *,
        global_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param global_defaults: (experimental) Allows you to specify the global defaults, which can be overridden in the individual metrics or alarms.

        :stability: experimental
        '''
        if isinstance(global_defaults, dict):
            global_defaults = MetricFactoryDefaults(**global_defaults)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f45f196b0d9a3e2fa1b57860efd2c9ed85ce8a4354aab4c9b818381abce63df2)
            check_type(argname="argument global_defaults", value=global_defaults, expected_type=type_hints["global_defaults"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if global_defaults is not None:
            self._values["global_defaults"] = global_defaults

    @builtins.property
    def global_defaults(self) -> typing.Optional[MetricFactoryDefaults]:
        '''(experimental) Allows you to specify the global defaults, which can be overridden in the individual metrics or alarms.

        :stability: experimental
        '''
        result = self._values.get("global_defaults")
        return typing.cast(typing.Optional[MetricFactoryDefaults], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.MetricStatistic")
class MetricStatistic(enum.Enum):
    '''(experimental) Metric aggregation statistic to be used with the IMetric objects.

    :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html
    :stability: experimental
    '''

    P50 = "P50"
    '''(experimental) 50th percentile of all datapoints.

    :stability: experimental
    '''
    P70 = "P70"
    '''(experimental) 70th percentile of all datapoints.

    :stability: experimental
    '''
    P90 = "P90"
    '''(experimental) 90th percentile of all datapoints.

    :stability: experimental
    '''
    P95 = "P95"
    '''(experimental) 95th percentile of all datapoints.

    :stability: experimental
    '''
    P99 = "P99"
    '''(experimental) 99th percentile of all datapoints.

    :stability: experimental
    '''
    P999 = "P999"
    '''(experimental) 99.9th percentile of all datapoints.

    :stability: experimental
    '''
    P9999 = "P9999"
    '''(experimental) 99.99th percentile of all datapoints.

    :stability: experimental
    '''
    P100 = "P100"
    '''(experimental) 100th percentile of all datapoints.

    :stability: experimental
    '''
    TM50 = "TM50"
    '''(experimental) trimmed mean;

    calculates the average after removing the 50% of data points with the highest values

    :stability: experimental
    '''
    TM70 = "TM70"
    '''(experimental) trimmed mean;

    calculates the average after removing the 30% of data points with the highest values

    :stability: experimental
    '''
    TM90 = "TM90"
    '''(experimental) trimmed mean;

    calculates the average after removing the 10% of data points with the highest values

    :stability: experimental
    '''
    TM95 = "TM95"
    '''(experimental) trimmed mean;

    calculates the average after removing the 5% of data points with the highest values

    :stability: experimental
    '''
    TM99 = "TM99"
    '''(experimental) trimmed mean;

    calculates the average after removing the 1% of data points with the highest values

    :stability: experimental
    '''
    TM999 = "TM999"
    '''(experimental) trimmed mean;

    calculates the average after removing the 0.1% of data points with the highest values

    :stability: experimental
    '''
    TM9999 = "TM9999"
    '''(experimental) trimmed mean;

    calculates the average after removing the 0.01% of data points with the highest values

    :stability: experimental
    '''
    TM99_BOTH = "TM99_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 1% lowest data points and the 1% highest data points

    :stability: experimental
    '''
    TM95_BOTH = "TM95_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 5% lowest data points and the 5% highest data points

    :stability: experimental
    '''
    TM90_BOTH = "TM90_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 10% lowest data points and the 10% highest data points

    :stability: experimental
    '''
    TM85_BOTH = "TM85_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 15% lowest data points and the 15% highest data points

    :stability: experimental
    '''
    TM80_BOTH = "TM80_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 20% lowest data points and the 20% highest data points

    :stability: experimental
    '''
    TM75_BOTH = "TM75_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 25% lowest data points and the 25% highest data points

    :stability: experimental
    '''
    TM70_BOTH = "TM70_BOTH"
    '''(experimental) trimmed mean;

    calculates the average after removing the 30% lowest data points and the 30% highest data points

    :stability: experimental
    '''
    TM95_TOP = "TM95_TOP"
    '''(experimental) trimmed mean;

    calculates the average after removing the 95% lowest data points

    :stability: experimental
    '''
    TM99_TOP = "TM99_TOP"
    '''(experimental) trimmed mean;

    calculates the average after removing the 99% lowest data points

    :stability: experimental
    '''
    TM999_TOP = "TM999_TOP"
    '''(experimental) trimmed mean;

    calculates the average after removing the 99.9% lowest data points

    :stability: experimental
    '''
    TM9999_TOP = "TM9999_TOP"
    '''(experimental) trimmed mean;

    calculates the average after removing the 99.99% lowest data points

    :stability: experimental
    '''
    WM50 = "WM50"
    '''(experimental) winsorized mean;

    calculates the average while treating the 50% of the highest values to be equal to the value at the 50th percentile

    :stability: experimental
    '''
    WM70 = "WM70"
    '''(experimental) winsorized mean;

    calculates the average while treating the 30% of the highest values to be equal to the value at the 70th percentile

    :stability: experimental
    '''
    WM90 = "WM90"
    '''(experimental) winsorized mean;

    calculates the average while treating the 10% of the highest values to be equal to the value at the 90th percentile

    :stability: experimental
    '''
    WM95 = "WM95"
    '''(experimental) winsorized mean;

    calculates the average while treating the 5% of the highest values to be equal to the value at the 95th percentile

    :stability: experimental
    '''
    WM99 = "WM99"
    '''(experimental) winsorized mean;

    calculates the average while treating the 1% of the highest values to be equal to the value at the 99th percentile

    :stability: experimental
    '''
    WM999 = "WM999"
    '''(experimental) winsorized mean;

    calculates the average while treating the 0.1% of the highest values to be equal to the value at the 99.9th percentile

    :stability: experimental
    '''
    WM9999 = "WM9999"
    '''(experimental) winsorized mean;

    calculates the average while treating the 0.01% of the highest values to be equal to the value at the 99.99th percentile

    :stability: experimental
    '''
    WM99_BOTH = "WM99_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 1% of data points to be the value of the 99% boundary, and treating the lowest 1% of data points to be the value of the 1% boundary

    :stability: experimental
    '''
    WM95_BOTH = "WM95_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 5% of data points to be the value of the 95% boundary, and treating the lowest 5% of data points to be the value of the 5% boundary

    :stability: experimental
    '''
    WM90_BOTH = "WM90_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 10% of data points to be the value of the 90% boundary, and treating the lowest 10% of data points to be the value of the 10% boundary

    :stability: experimental
    '''
    WM85_BOTH = "WM85_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 15% of data points to be the value of the 85% boundary, and treating the lowest 15% of data points to be the value of the 15% boundary

    :stability: experimental
    '''
    WM80_BOTH = "WM80_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 20% of data points to be the value of the 80% boundary, and treating the lowest 20% of data points to be the value of the 20% boundary

    :stability: experimental
    '''
    WM75_BOTH = "WM75_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 25% of data points to be the value of the 75% boundary, and treating the lowest 25% of data points to be the value of the 25% boundary

    :stability: experimental
    '''
    WM70_BOTH = "WM70_BOTH"
    '''(experimental) winsorized mean;

    calculates the average while treating the highest 30% of data points to be the value of the 70% boundary, and treating the lowest 30% of data points to be the value of the 30% boundary

    :stability: experimental
    '''
    MIN = "MIN"
    '''(experimental) minimum of all datapoints.

    :stability: experimental
    '''
    MAX = "MAX"
    '''(experimental) maximum of all datapoints.

    :stability: experimental
    '''
    SUM = "SUM"
    '''(experimental) sum of all datapoints.

    :stability: experimental
    '''
    AVERAGE = "AVERAGE"
    '''(experimental) average of all datapoints.

    :stability: experimental
    '''
    N = "N"
    '''(experimental) number of datapoints.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinFreeableMemoryThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_freeable_memory_in_bytes": "minFreeableMemoryInBytes",
    },
)
class MinFreeableMemoryThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_freeable_memory_in_bytes: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_freeable_memory_in_bytes: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e71e0b8c1d99b1db88de5bfc17a53d4e99a744e3ebcc4aa4f56ae726af7780db)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_freeable_memory_in_bytes", value=min_freeable_memory_in_bytes, expected_type=type_hints["min_freeable_memory_in_bytes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_freeable_memory_in_bytes": min_freeable_memory_in_bytes,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_freeable_memory_in_bytes(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_freeable_memory_in_bytes")
        assert result is not None, "Required property 'min_freeable_memory_in_bytes' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinFreeableMemoryThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinIncomingMessagesCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_incoming_messages_count": "minIncomingMessagesCount",
    },
)
class MinIncomingMessagesCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_incoming_messages_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_incoming_messages_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7c7406d35f20af74b8f9b9812a27f0fcdc19edf2c3c24a241cf6fd5cc0709025)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_incoming_messages_count", value=min_incoming_messages_count, expected_type=type_hints["min_incoming_messages_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_incoming_messages_count": min_incoming_messages_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_incoming_messages_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_incoming_messages_count")
        assert result is not None, "Required property 'min_incoming_messages_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinIncomingMessagesCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinMessageCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_message_count": "minMessageCount",
    },
)
class MinMessageCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_message_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_message_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e86df53f4be5abd3ba4c03f389ee81a413826f3a3157366551e7694d5657fc42)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_message_count", value=min_message_count, expected_type=type_hints["min_message_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_message_count": min_message_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_message_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_message_count")
        assert result is not None, "Required property 'min_message_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinMessageCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinProcessedBytesThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_processed_bytes": "minProcessedBytes",
    },
)
class MinProcessedBytesThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_processed_bytes: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_processed_bytes: (experimental) Threshold for the least number of bytes processed.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2d3d52f4ae987afb2ccb70baef64ae9641aa5c154538fa8f053b525c21a5135)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_processed_bytes", value=min_processed_bytes, expected_type=type_hints["min_processed_bytes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_processed_bytes": min_processed_bytes,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_processed_bytes(self) -> jsii.Number:
        '''(experimental) Threshold for the least number of bytes processed.

        :stability: experimental
        '''
        result = self._values.get("min_processed_bytes")
        assert result is not None, "Required property 'min_processed_bytes' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinProcessedBytesThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinRunningTaskCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_running_tasks": "minRunningTasks",
    },
)
class MinRunningTaskCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_running_tasks: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_running_tasks: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd707297df29d4f351c909ca37deb4d16a7d302aaae89615693443a404d37c02)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_running_tasks", value=min_running_tasks, expected_type=type_hints["min_running_tasks"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_running_tasks": min_running_tasks,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_running_tasks(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_running_tasks")
        assert result is not None, "Required property 'min_running_tasks' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinRunningTaskCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinSecretCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_secret_count": "minSecretCount",
    },
)
class MinSecretCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_secret_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_secret_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03bc7bb921d6d3dc1ba1941eba1eedc413e7e4339cfe71d35f249d2ef36ea8b4)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_secret_count", value=min_secret_count, expected_type=type_hints["min_secret_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_secret_count": min_secret_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_secret_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_secret_count")
        assert result is not None, "Required property 'min_secret_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinSecretCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MinUsageCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_count": "minCount",
    },
)
class MinUsageCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d5dc68520bfab68b018f19a1c3f43d98a742687a3b0007dff100e8a0837304e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_count", value=min_count, expected_type=type_hints["min_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_count": min_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_count")
        assert result is not None, "Required property 'min_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MinUsageCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IDashboardSegment, IDynamicDashboardSegment)
class Monitoring(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdk-monitoring-constructs.Monitoring",
):
    '''(experimental) An independent unit of monitoring.

    This is the base for all monitoring classes with alarm support.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "MonitoringScope",
        *,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1756f17ca9efa13a3497f07fcaa049b4483d5a440293ad9c1625a1f27e143123)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = BaseMonitoringProps(
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="addAlarm")
    def add_alarm(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        alarm_description: builtins.str,
        alarm_label: builtins.str,
        alarm_name: builtins.str,
        alarm_name_suffix: builtins.str,
        alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Adds an alarm.

        :param alarm: 
        :param alarm_description: 
        :param alarm_label: 
        :param alarm_name: 
        :param alarm_name_suffix: 
        :param alarm_rule_when_alarming: 
        :param alarm_rule_when_insufficient_data: 
        :param alarm_rule_when_ok: 
        :param annotation: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        alarm_ = AlarmWithAnnotation(
            alarm=alarm,
            alarm_description=alarm_description,
            alarm_label=alarm_label,
            alarm_name=alarm_name,
            alarm_name_suffix=alarm_name_suffix,
            alarm_rule_when_alarming=alarm_rule_when_alarming,
            alarm_rule_when_insufficient_data=alarm_rule_when_insufficient_data,
            alarm_rule_when_ok=alarm_rule_when_ok,
            annotation=annotation,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarm", [alarm_]))

    @jsii.member(jsii_name="alarmWidgets")
    def alarm_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for all alarms.

        These can go to runbook or to service dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "alarmWidgets", []))

    @jsii.member(jsii_name="createAlarmFactory")
    def create_alarm_factory(self, alarm_name_prefix: builtins.str) -> AlarmFactory:
        '''(experimental) Creates a new alarm factory.

        Alarms created will be named with the given prefix, unless a local name override is present.

        :param alarm_name_prefix: alarm name prefix.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__abb59c5ed96be70b1333d46e794e8225b3c97f8855e992451fd7502363bbfb88)
            check_type(argname="argument alarm_name_prefix", value=alarm_name_prefix, expected_type=type_hints["alarm_name_prefix"])
        return typing.cast(AlarmFactory, jsii.invoke(self, "createAlarmFactory", [alarm_name_prefix]))

    @jsii.member(jsii_name="createdAlarms")
    def created_alarms(self) -> typing.List[AlarmWithAnnotation]:
        '''(experimental) Returns all the alarms created.

        :stability: experimental
        '''
        return typing.cast(typing.List[AlarmWithAnnotation], jsii.invoke(self, "createdAlarms", []))

    @jsii.member(jsii_name="createMetricFactory")
    def create_metric_factory(self) -> MetricFactory:
        '''(experimental) Creates a new metric factory.

        :stability: experimental
        '''
        return typing.cast(MetricFactory, jsii.invoke(self, "createMetricFactory", []))

    @jsii.member(jsii_name="createWidgetFactory")
    def create_widget_factory(self) -> IWidgetFactory:
        '''(experimental) Creates a new widget factory.

        :stability: experimental
        '''
        return typing.cast(IWidgetFactory, jsii.invoke(self, "createWidgetFactory", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :default: - no widgets.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    @abc.abstractmethod
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="widgetsForDashboard")
    def widgets_for_dashboard(
        self,
        name: builtins.str,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the requested dashboard type.

        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b12926dcd1d8a2c178228c89f5f2683f5d7064fb09fc13087d5d63a7f1ee9052)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgetsForDashboard", [name]))

    @builtins.property
    @jsii.member(jsii_name="alarms")
    def _alarms(self) -> typing.List[AlarmWithAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[AlarmWithAnnotation], jsii.get(self, "alarms"))

    @builtins.property
    @jsii.member(jsii_name="scope")
    def _scope(self) -> "MonitoringScope":
        '''
        :stability: experimental
        '''
        return typing.cast("MonitoringScope", jsii.get(self, "scope"))

    @builtins.property
    @jsii.member(jsii_name="localAlarmNamePrefixOverride")
    def _local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "localAlarmNamePrefixOverride"))


class _MonitoringProxy(Monitoring):
    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, Monitoring).__jsii_proxy_class__ = lambda : _MonitoringProxy


@jsii.implements(_aws_cdk_ceddda9d.IAspect)
class MonitoringAspect(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MonitoringAspect",
):
    '''(experimental) A CDK aspect that adds support for monitoring all resources within scope.

    :stability: experimental
    '''

    def __init__(
        self,
        monitoring_facade: "MonitoringFacade",
        *,
        acm: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway_v2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        app_sync: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        aurora_cluster: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        auto_scaling_group: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        billing: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        cloud_front: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        code_build: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        document_db: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        dynamo_db: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        ec2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        elastic_cache: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        glue: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_analytics: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_stream: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_firehose: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        lambda_: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        open_search: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds_cluster: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds_instance: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        redshift: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        s3: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        secrets_manager: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        sns: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        sqs: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        step_functions: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        synthetics_canaries: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        web_application_firewall_acl_v2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param monitoring_facade: -
        :param acm: 
        :param api_gateway: 
        :param api_gateway_v2: 
        :param app_sync: 
        :param aurora_cluster: 
        :param auto_scaling_group: 
        :param billing: 
        :param cloud_front: 
        :param code_build: 
        :param document_db: 
        :param dynamo_db: 
        :param ec2: 
        :param elastic_cache: 
        :param glue: 
        :param kinesis_data_analytics: 
        :param kinesis_data_stream: 
        :param kinesis_firehose: 
        :param lambda_: 
        :param open_search: 
        :param rds: 
        :param rds_cluster: 
        :param rds_instance: 
        :param redshift: 
        :param s3: 
        :param secrets_manager: 
        :param sns: 
        :param sqs: 
        :param step_functions: 
        :param synthetics_canaries: 
        :param web_application_firewall_acl_v2: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6901860bcf3b0545043f3b3d08fb673a71ff9d423d729c3306f97f0e0a03ae5d)
            check_type(argname="argument monitoring_facade", value=monitoring_facade, expected_type=type_hints["monitoring_facade"])
        props = MonitoringAspectProps(
            acm=acm,
            api_gateway=api_gateway,
            api_gateway_v2=api_gateway_v2,
            app_sync=app_sync,
            aurora_cluster=aurora_cluster,
            auto_scaling_group=auto_scaling_group,
            billing=billing,
            cloud_front=cloud_front,
            code_build=code_build,
            document_db=document_db,
            dynamo_db=dynamo_db,
            ec2=ec2,
            elastic_cache=elastic_cache,
            glue=glue,
            kinesis_data_analytics=kinesis_data_analytics,
            kinesis_data_stream=kinesis_data_stream,
            kinesis_firehose=kinesis_firehose,
            lambda_=lambda_,
            open_search=open_search,
            rds=rds,
            rds_cluster=rds_cluster,
            rds_instance=rds_instance,
            redshift=redshift,
            s3=s3,
            secrets_manager=secrets_manager,
            sns=sns,
            sqs=sqs,
            step_functions=step_functions,
            synthetics_canaries=synthetics_canaries,
            web_application_firewall_acl_v2=web_application_firewall_acl_v2,
        )

        jsii.create(self.__class__, self, [monitoring_facade, props])

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''(experimental) All aspects can visit an IConstruct.

        :param node: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4185d86551c5e33233fc7123c80e4723734199b801bd1d89df477d783153074a)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast(None, jsii.invoke(self, "visit", [node]))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringAspectProps",
    jsii_struct_bases=[],
    name_mapping={
        "acm": "acm",
        "api_gateway": "apiGateway",
        "api_gateway_v2": "apiGatewayV2",
        "app_sync": "appSync",
        "aurora_cluster": "auroraCluster",
        "auto_scaling_group": "autoScalingGroup",
        "billing": "billing",
        "cloud_front": "cloudFront",
        "code_build": "codeBuild",
        "document_db": "documentDb",
        "dynamo_db": "dynamoDB",
        "ec2": "ec2",
        "elastic_cache": "elasticCache",
        "glue": "glue",
        "kinesis_data_analytics": "kinesisDataAnalytics",
        "kinesis_data_stream": "kinesisDataStream",
        "kinesis_firehose": "kinesisFirehose",
        "lambda_": "lambda",
        "open_search": "openSearch",
        "rds": "rds",
        "rds_cluster": "rdsCluster",
        "rds_instance": "rdsInstance",
        "redshift": "redshift",
        "s3": "s3",
        "secrets_manager": "secretsManager",
        "sns": "sns",
        "sqs": "sqs",
        "step_functions": "stepFunctions",
        "synthetics_canaries": "syntheticsCanaries",
        "web_application_firewall_acl_v2": "webApplicationFirewallAclV2",
    },
)
class MonitoringAspectProps:
    def __init__(
        self,
        *,
        acm: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway_v2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        app_sync: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        aurora_cluster: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        auto_scaling_group: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        billing: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        cloud_front: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        code_build: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        document_db: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        dynamo_db: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        ec2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        elastic_cache: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        glue: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_analytics: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_stream: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_firehose: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        lambda_: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        open_search: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds_cluster: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        rds_instance: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        redshift: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        s3: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        secrets_manager: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        sns: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        sqs: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        step_functions: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        synthetics_canaries: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
        web_application_firewall_acl_v2: typing.Optional[typing.Union["MonitoringAspectType", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param acm: 
        :param api_gateway: 
        :param api_gateway_v2: 
        :param app_sync: 
        :param aurora_cluster: 
        :param auto_scaling_group: 
        :param billing: 
        :param cloud_front: 
        :param code_build: 
        :param document_db: 
        :param dynamo_db: 
        :param ec2: 
        :param elastic_cache: 
        :param glue: 
        :param kinesis_data_analytics: 
        :param kinesis_data_stream: 
        :param kinesis_firehose: 
        :param lambda_: 
        :param open_search: 
        :param rds: 
        :param rds_cluster: 
        :param rds_instance: 
        :param redshift: 
        :param s3: 
        :param secrets_manager: 
        :param sns: 
        :param sqs: 
        :param step_functions: 
        :param synthetics_canaries: 
        :param web_application_firewall_acl_v2: 

        :stability: experimental
        '''
        if isinstance(acm, dict):
            acm = MonitoringAspectType(**acm)
        if isinstance(api_gateway, dict):
            api_gateway = MonitoringAspectType(**api_gateway)
        if isinstance(api_gateway_v2, dict):
            api_gateway_v2 = MonitoringAspectType(**api_gateway_v2)
        if isinstance(app_sync, dict):
            app_sync = MonitoringAspectType(**app_sync)
        if isinstance(aurora_cluster, dict):
            aurora_cluster = MonitoringAspectType(**aurora_cluster)
        if isinstance(auto_scaling_group, dict):
            auto_scaling_group = MonitoringAspectType(**auto_scaling_group)
        if isinstance(billing, dict):
            billing = MonitoringAspectType(**billing)
        if isinstance(cloud_front, dict):
            cloud_front = MonitoringAspectType(**cloud_front)
        if isinstance(code_build, dict):
            code_build = MonitoringAspectType(**code_build)
        if isinstance(document_db, dict):
            document_db = MonitoringAspectType(**document_db)
        if isinstance(dynamo_db, dict):
            dynamo_db = MonitoringAspectType(**dynamo_db)
        if isinstance(ec2, dict):
            ec2 = MonitoringAspectType(**ec2)
        if isinstance(elastic_cache, dict):
            elastic_cache = MonitoringAspectType(**elastic_cache)
        if isinstance(glue, dict):
            glue = MonitoringAspectType(**glue)
        if isinstance(kinesis_data_analytics, dict):
            kinesis_data_analytics = MonitoringAspectType(**kinesis_data_analytics)
        if isinstance(kinesis_data_stream, dict):
            kinesis_data_stream = MonitoringAspectType(**kinesis_data_stream)
        if isinstance(kinesis_firehose, dict):
            kinesis_firehose = MonitoringAspectType(**kinesis_firehose)
        if isinstance(lambda_, dict):
            lambda_ = MonitoringAspectType(**lambda_)
        if isinstance(open_search, dict):
            open_search = MonitoringAspectType(**open_search)
        if isinstance(rds, dict):
            rds = MonitoringAspectType(**rds)
        if isinstance(rds_cluster, dict):
            rds_cluster = MonitoringAspectType(**rds_cluster)
        if isinstance(rds_instance, dict):
            rds_instance = MonitoringAspectType(**rds_instance)
        if isinstance(redshift, dict):
            redshift = MonitoringAspectType(**redshift)
        if isinstance(s3, dict):
            s3 = MonitoringAspectType(**s3)
        if isinstance(secrets_manager, dict):
            secrets_manager = MonitoringAspectType(**secrets_manager)
        if isinstance(sns, dict):
            sns = MonitoringAspectType(**sns)
        if isinstance(sqs, dict):
            sqs = MonitoringAspectType(**sqs)
        if isinstance(step_functions, dict):
            step_functions = MonitoringAspectType(**step_functions)
        if isinstance(synthetics_canaries, dict):
            synthetics_canaries = MonitoringAspectType(**synthetics_canaries)
        if isinstance(web_application_firewall_acl_v2, dict):
            web_application_firewall_acl_v2 = MonitoringAspectType(**web_application_firewall_acl_v2)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34933099e595bccf3bf326147d8e6e6e1a8db2c126e288a7a3aa41cb6a1d969b)
            check_type(argname="argument acm", value=acm, expected_type=type_hints["acm"])
            check_type(argname="argument api_gateway", value=api_gateway, expected_type=type_hints["api_gateway"])
            check_type(argname="argument api_gateway_v2", value=api_gateway_v2, expected_type=type_hints["api_gateway_v2"])
            check_type(argname="argument app_sync", value=app_sync, expected_type=type_hints["app_sync"])
            check_type(argname="argument aurora_cluster", value=aurora_cluster, expected_type=type_hints["aurora_cluster"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
            check_type(argname="argument billing", value=billing, expected_type=type_hints["billing"])
            check_type(argname="argument cloud_front", value=cloud_front, expected_type=type_hints["cloud_front"])
            check_type(argname="argument code_build", value=code_build, expected_type=type_hints["code_build"])
            check_type(argname="argument document_db", value=document_db, expected_type=type_hints["document_db"])
            check_type(argname="argument dynamo_db", value=dynamo_db, expected_type=type_hints["dynamo_db"])
            check_type(argname="argument ec2", value=ec2, expected_type=type_hints["ec2"])
            check_type(argname="argument elastic_cache", value=elastic_cache, expected_type=type_hints["elastic_cache"])
            check_type(argname="argument glue", value=glue, expected_type=type_hints["glue"])
            check_type(argname="argument kinesis_data_analytics", value=kinesis_data_analytics, expected_type=type_hints["kinesis_data_analytics"])
            check_type(argname="argument kinesis_data_stream", value=kinesis_data_stream, expected_type=type_hints["kinesis_data_stream"])
            check_type(argname="argument kinesis_firehose", value=kinesis_firehose, expected_type=type_hints["kinesis_firehose"])
            check_type(argname="argument lambda_", value=lambda_, expected_type=type_hints["lambda_"])
            check_type(argname="argument open_search", value=open_search, expected_type=type_hints["open_search"])
            check_type(argname="argument rds", value=rds, expected_type=type_hints["rds"])
            check_type(argname="argument rds_cluster", value=rds_cluster, expected_type=type_hints["rds_cluster"])
            check_type(argname="argument rds_instance", value=rds_instance, expected_type=type_hints["rds_instance"])
            check_type(argname="argument redshift", value=redshift, expected_type=type_hints["redshift"])
            check_type(argname="argument s3", value=s3, expected_type=type_hints["s3"])
            check_type(argname="argument secrets_manager", value=secrets_manager, expected_type=type_hints["secrets_manager"])
            check_type(argname="argument sns", value=sns, expected_type=type_hints["sns"])
            check_type(argname="argument sqs", value=sqs, expected_type=type_hints["sqs"])
            check_type(argname="argument step_functions", value=step_functions, expected_type=type_hints["step_functions"])
            check_type(argname="argument synthetics_canaries", value=synthetics_canaries, expected_type=type_hints["synthetics_canaries"])
            check_type(argname="argument web_application_firewall_acl_v2", value=web_application_firewall_acl_v2, expected_type=type_hints["web_application_firewall_acl_v2"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if acm is not None:
            self._values["acm"] = acm
        if api_gateway is not None:
            self._values["api_gateway"] = api_gateway
        if api_gateway_v2 is not None:
            self._values["api_gateway_v2"] = api_gateway_v2
        if app_sync is not None:
            self._values["app_sync"] = app_sync
        if aurora_cluster is not None:
            self._values["aurora_cluster"] = aurora_cluster
        if auto_scaling_group is not None:
            self._values["auto_scaling_group"] = auto_scaling_group
        if billing is not None:
            self._values["billing"] = billing
        if cloud_front is not None:
            self._values["cloud_front"] = cloud_front
        if code_build is not None:
            self._values["code_build"] = code_build
        if document_db is not None:
            self._values["document_db"] = document_db
        if dynamo_db is not None:
            self._values["dynamo_db"] = dynamo_db
        if ec2 is not None:
            self._values["ec2"] = ec2
        if elastic_cache is not None:
            self._values["elastic_cache"] = elastic_cache
        if glue is not None:
            self._values["glue"] = glue
        if kinesis_data_analytics is not None:
            self._values["kinesis_data_analytics"] = kinesis_data_analytics
        if kinesis_data_stream is not None:
            self._values["kinesis_data_stream"] = kinesis_data_stream
        if kinesis_firehose is not None:
            self._values["kinesis_firehose"] = kinesis_firehose
        if lambda_ is not None:
            self._values["lambda_"] = lambda_
        if open_search is not None:
            self._values["open_search"] = open_search
        if rds is not None:
            self._values["rds"] = rds
        if rds_cluster is not None:
            self._values["rds_cluster"] = rds_cluster
        if rds_instance is not None:
            self._values["rds_instance"] = rds_instance
        if redshift is not None:
            self._values["redshift"] = redshift
        if s3 is not None:
            self._values["s3"] = s3
        if secrets_manager is not None:
            self._values["secrets_manager"] = secrets_manager
        if sns is not None:
            self._values["sns"] = sns
        if sqs is not None:
            self._values["sqs"] = sqs
        if step_functions is not None:
            self._values["step_functions"] = step_functions
        if synthetics_canaries is not None:
            self._values["synthetics_canaries"] = synthetics_canaries
        if web_application_firewall_acl_v2 is not None:
            self._values["web_application_firewall_acl_v2"] = web_application_firewall_acl_v2

    @builtins.property
    def acm(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("acm")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def api_gateway(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("api_gateway")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def api_gateway_v2(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("api_gateway_v2")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def app_sync(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("app_sync")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def aurora_cluster(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("aurora_cluster")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def auto_scaling_group(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def billing(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("billing")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def cloud_front(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("cloud_front")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def code_build(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("code_build")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def document_db(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("document_db")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def dynamo_db(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dynamo_db")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def ec2(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def elastic_cache(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("elastic_cache")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def glue(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("glue")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def kinesis_data_analytics(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("kinesis_data_analytics")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def kinesis_data_stream(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("kinesis_data_stream")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def kinesis_firehose(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("kinesis_firehose")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def lambda_(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def open_search(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("open_search")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def rds(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :deprecated: Use rdsCluster instead.

        :stability: deprecated
        '''
        result = self._values.get("rds")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def rds_cluster(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("rds_cluster")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def rds_instance(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("rds_instance")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def redshift(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("redshift")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def s3(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("s3")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def secrets_manager(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("secrets_manager")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def sns(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("sns")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def sqs(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("sqs")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def step_functions(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("step_functions")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def synthetics_canaries(self) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("synthetics_canaries")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    @builtins.property
    def web_application_firewall_acl_v2(
        self,
    ) -> typing.Optional["MonitoringAspectType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("web_application_firewall_acl_v2")
        return typing.cast(typing.Optional["MonitoringAspectType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringAspectProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringAspectType",
    jsii_struct_bases=[],
    name_mapping={"enabled": "enabled", "props": "props"},
)
class MonitoringAspectType:
    def __init__(
        self,
        *,
        enabled: typing.Optional[builtins.bool] = None,
        props: typing.Any = None,
    ) -> None:
        '''
        :param enabled: (experimental) If the monitoring aspect is enabled for this resource. Default: - true
        :param props: (experimental) The monitoring props for this resource. Default: - none

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b29f63ffaa6a077b48061c895deb13e392edd41edbb04e4d697c49ba71d3867)
            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if enabled is not None:
            self._values["enabled"] = enabled
        if props is not None:
            self._values["props"] = props

    @builtins.property
    def enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If the monitoring aspect is enabled for this resource.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def props(self) -> typing.Any:
        '''(experimental) The monitoring props for this resource.

        :default: - none

        :stability: experimental
        '''
        result = self._values.get("props")
        return typing.cast(typing.Any, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringAspectType(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringDashboardsOverrideProps",
    jsii_struct_bases=[],
    name_mapping={
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
    },
)
class MonitoringDashboardsOverrideProps:
    def __init__(
        self,
        *,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cffb3bf01cde969b1448a7c5f8684dd36613d7a76aba8b9a49c43d0d428f051e)
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringDashboardsOverrideProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringDashboardsProps",
    jsii_struct_bases=[],
    name_mapping={
        "dashboard_name_prefix": "dashboardNamePrefix",
        "create_alarm_dashboard": "createAlarmDashboard",
        "create_dashboard": "createDashboard",
        "create_summary_dashboard": "createSummaryDashboard",
        "detail_dashboard_period_override": "detailDashboardPeriodOverride",
        "detail_dashboard_range": "detailDashboardRange",
        "rendering_preference": "renderingPreference",
        "summary_dashboard_period_override": "summaryDashboardPeriodOverride",
        "summary_dashboard_range": "summaryDashboardRange",
    },
)
class MonitoringDashboardsProps:
    def __init__(
        self,
        *,
        dashboard_name_prefix: builtins.str,
        create_alarm_dashboard: typing.Optional[builtins.bool] = None,
        create_dashboard: typing.Optional[builtins.bool] = None,
        create_summary_dashboard: typing.Optional[builtins.bool] = None,
        detail_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        detail_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
        summary_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        summary_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''
        :param dashboard_name_prefix: (experimental) Prefix added to each dashboard name. This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.
        :param create_alarm_dashboard: (experimental) Flag indicating whether the alarm dashboard should be created. This is independent on other create dashboard flags. Default: - false
        :param create_dashboard: (experimental) Flag indicating whether the default dashboard should be created. This is independent on other create dashboard flags. Default: - true
        :param create_summary_dashboard: (experimental) Flag indicating whether the summary dashboard should be created. This is independent on other create dashboard flags. Default: - false
        :param detail_dashboard_period_override: (experimental) Period override for the detail dashboard (and other auxiliary dashboards). Default: - respect individual graphs (PeriodOverride.INHERIT)
        :param detail_dashboard_range: (experimental) Range of the detail dashboard (and other auxiliary dashboards). Default: - 8 hours
        :param rendering_preference: (experimental) Dashboard rendering preference. Default: - DashboardRenderingPreference.INTERACTIVE_ONLY
        :param summary_dashboard_period_override: (experimental) Period override for the summary dashboard. Default: - respect individual graphs (PeriodOverride.INHERIT)
        :param summary_dashboard_range: (experimental) Range of the summary dashboard. Default: - 14 days

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__901755619e0c3833c4ed1087c81e3359bea6187173fd9404433aaa0b68ae1ac4)
            check_type(argname="argument dashboard_name_prefix", value=dashboard_name_prefix, expected_type=type_hints["dashboard_name_prefix"])
            check_type(argname="argument create_alarm_dashboard", value=create_alarm_dashboard, expected_type=type_hints["create_alarm_dashboard"])
            check_type(argname="argument create_dashboard", value=create_dashboard, expected_type=type_hints["create_dashboard"])
            check_type(argname="argument create_summary_dashboard", value=create_summary_dashboard, expected_type=type_hints["create_summary_dashboard"])
            check_type(argname="argument detail_dashboard_period_override", value=detail_dashboard_period_override, expected_type=type_hints["detail_dashboard_period_override"])
            check_type(argname="argument detail_dashboard_range", value=detail_dashboard_range, expected_type=type_hints["detail_dashboard_range"])
            check_type(argname="argument rendering_preference", value=rendering_preference, expected_type=type_hints["rendering_preference"])
            check_type(argname="argument summary_dashboard_period_override", value=summary_dashboard_period_override, expected_type=type_hints["summary_dashboard_period_override"])
            check_type(argname="argument summary_dashboard_range", value=summary_dashboard_range, expected_type=type_hints["summary_dashboard_range"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "dashboard_name_prefix": dashboard_name_prefix,
        }
        if create_alarm_dashboard is not None:
            self._values["create_alarm_dashboard"] = create_alarm_dashboard
        if create_dashboard is not None:
            self._values["create_dashboard"] = create_dashboard
        if create_summary_dashboard is not None:
            self._values["create_summary_dashboard"] = create_summary_dashboard
        if detail_dashboard_period_override is not None:
            self._values["detail_dashboard_period_override"] = detail_dashboard_period_override
        if detail_dashboard_range is not None:
            self._values["detail_dashboard_range"] = detail_dashboard_range
        if rendering_preference is not None:
            self._values["rendering_preference"] = rendering_preference
        if summary_dashboard_period_override is not None:
            self._values["summary_dashboard_period_override"] = summary_dashboard_period_override
        if summary_dashboard_range is not None:
            self._values["summary_dashboard_range"] = summary_dashboard_range

    @builtins.property
    def dashboard_name_prefix(self) -> builtins.str:
        '''(experimental) Prefix added to each dashboard name.

        This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.

        :stability: experimental
        '''
        result = self._values.get("dashboard_name_prefix")
        assert result is not None, "Required property 'dashboard_name_prefix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def create_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating whether the alarm dashboard should be created.

        This is independent on other create dashboard flags.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("create_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def create_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating whether the default dashboard should be created.

        This is independent on other create dashboard flags.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("create_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def create_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating whether the summary dashboard should be created.

        This is independent on other create dashboard flags.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("create_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def detail_dashboard_period_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride]:
        '''(experimental) Period override for the detail dashboard (and other auxiliary dashboards).

        :default: - respect individual graphs (PeriodOverride.INHERIT)

        :stability: experimental
        '''
        result = self._values.get("detail_dashboard_period_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride], result)

    @builtins.property
    def detail_dashboard_range(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Range of the detail dashboard (and other auxiliary dashboards).

        :default: - 8 hours

        :see: DefaultDetailDashboardRange
        :stability: experimental
        '''
        result = self._values.get("detail_dashboard_range")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def rendering_preference(self) -> typing.Optional[DashboardRenderingPreference]:
        '''(experimental) Dashboard rendering preference.

        :default: - DashboardRenderingPreference.INTERACTIVE_ONLY

        :stability: experimental
        '''
        result = self._values.get("rendering_preference")
        return typing.cast(typing.Optional[DashboardRenderingPreference], result)

    @builtins.property
    def summary_dashboard_period_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride]:
        '''(experimental) Period override for the summary dashboard.

        :default: - respect individual graphs (PeriodOverride.INHERIT)

        :stability: experimental
        '''
        result = self._values.get("summary_dashboard_period_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride], result)

    @builtins.property
    def summary_dashboard_range(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Range of the summary dashboard.

        :default: - 14 days

        :stability: experimental
        '''
        result = self._values.get("summary_dashboard_range")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringDashboardsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringDynamicDashboardsProps",
    jsii_struct_bases=[],
    name_mapping={
        "dashboard_configs": "dashboardConfigs",
        "dashboard_name_prefix": "dashboardNamePrefix",
    },
)
class MonitoringDynamicDashboardsProps:
    def __init__(
        self,
        *,
        dashboard_configs: typing.Sequence[typing.Union[DynamicDashboardConfiguration, typing.Dict[builtins.str, typing.Any]]],
        dashboard_name_prefix: builtins.str,
    ) -> None:
        '''
        :param dashboard_configs: (experimental) List of dashboard types to generate.
        :param dashboard_name_prefix: (experimental) Prefix added to each dashboard's name. This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2062930491aa62ff0642d6ee7effbc58a68f2bbe7b3b838694d8835e4b32143)
            check_type(argname="argument dashboard_configs", value=dashboard_configs, expected_type=type_hints["dashboard_configs"])
            check_type(argname="argument dashboard_name_prefix", value=dashboard_name_prefix, expected_type=type_hints["dashboard_name_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "dashboard_configs": dashboard_configs,
            "dashboard_name_prefix": dashboard_name_prefix,
        }

    @builtins.property
    def dashboard_configs(self) -> typing.List[DynamicDashboardConfiguration]:
        '''(experimental) List of dashboard types to generate.

        :stability: experimental
        '''
        result = self._values.get("dashboard_configs")
        assert result is not None, "Required property 'dashboard_configs' is missing"
        return typing.cast(typing.List[DynamicDashboardConfiguration], result)

    @builtins.property
    def dashboard_name_prefix(self) -> builtins.str:
        '''(experimental) Prefix added to each dashboard's name.

        This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.

        :stability: experimental
        '''
        result = self._values.get("dashboard_name_prefix")
        assert result is not None, "Required property 'dashboard_name_prefix' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringDynamicDashboardsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringFacadeProps",
    jsii_struct_bases=[],
    name_mapping={
        "alarm_factory_defaults": "alarmFactoryDefaults",
        "dashboard_factory": "dashboardFactory",
        "metric_factory_defaults": "metricFactoryDefaults",
    },
)
class MonitoringFacadeProps:
    def __init__(
        self,
        *,
        alarm_factory_defaults: typing.Optional[typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
        dashboard_factory: typing.Optional[IDynamicDashboardFactory] = None,
        metric_factory_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param alarm_factory_defaults: (experimental) Defaults for alarm factory. Default: - actions enabled, facade logical ID used as default alarm name prefix
        :param dashboard_factory: (experimental) Defaults for dashboard factory. Default: - An instance of {@link DynamicDashboardFactory}; facade logical ID used as default name
        :param metric_factory_defaults: (experimental) Defaults for metric factory. Default: - empty (no preferences)

        :stability: experimental
        '''
        if isinstance(alarm_factory_defaults, dict):
            alarm_factory_defaults = AlarmFactoryDefaults(**alarm_factory_defaults)
        if isinstance(metric_factory_defaults, dict):
            metric_factory_defaults = MetricFactoryDefaults(**metric_factory_defaults)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b10df49c97391750f3ee7be142bcda1b1de8f475cecd2f8186c7a8a8eb2d1a40)
            check_type(argname="argument alarm_factory_defaults", value=alarm_factory_defaults, expected_type=type_hints["alarm_factory_defaults"])
            check_type(argname="argument dashboard_factory", value=dashboard_factory, expected_type=type_hints["dashboard_factory"])
            check_type(argname="argument metric_factory_defaults", value=metric_factory_defaults, expected_type=type_hints["metric_factory_defaults"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if alarm_factory_defaults is not None:
            self._values["alarm_factory_defaults"] = alarm_factory_defaults
        if dashboard_factory is not None:
            self._values["dashboard_factory"] = dashboard_factory
        if metric_factory_defaults is not None:
            self._values["metric_factory_defaults"] = metric_factory_defaults

    @builtins.property
    def alarm_factory_defaults(self) -> typing.Optional[AlarmFactoryDefaults]:
        '''(experimental) Defaults for alarm factory.

        :default: - actions enabled, facade logical ID used as default alarm name prefix

        :stability: experimental
        '''
        result = self._values.get("alarm_factory_defaults")
        return typing.cast(typing.Optional[AlarmFactoryDefaults], result)

    @builtins.property
    def dashboard_factory(self) -> typing.Optional[IDynamicDashboardFactory]:
        '''(experimental) Defaults for dashboard factory.

        :default: - An instance of {@link DynamicDashboardFactory}; facade logical ID used as default name

        :stability: experimental
        '''
        result = self._values.get("dashboard_factory")
        return typing.cast(typing.Optional[IDynamicDashboardFactory], result)

    @builtins.property
    def metric_factory_defaults(self) -> typing.Optional[MetricFactoryDefaults]:
        '''(experimental) Defaults for metric factory.

        :default: - empty (no preferences)

        :stability: experimental
        '''
        result = self._values.get("metric_factory_defaults")
        return typing.cast(typing.Optional[MetricFactoryDefaults], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringFacadeProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MonitoringHeaderWidget(
    HeaderWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MonitoringHeaderWidget",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        title: builtins.str,
        description: typing.Optional[builtins.str] = None,
        description_height: typing.Optional[jsii.Number] = None,
        family: typing.Optional[builtins.str] = None,
        go_to_link_url: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param title: 
        :param description: 
        :param description_height: 
        :param family: 
        :param go_to_link_url: 

        :stability: experimental
        '''
        props = MonitoringHeaderWidgetProps(
            title=title,
            description=description,
            description_height=description_height,
            family=family,
            go_to_link_url=go_to_link_url,
        )

        jsii.create(self.__class__, self, [props])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.MonitoringHeaderWidgetProps",
    jsii_struct_bases=[],
    name_mapping={
        "title": "title",
        "description": "description",
        "description_height": "descriptionHeight",
        "family": "family",
        "go_to_link_url": "goToLinkUrl",
    },
)
class MonitoringHeaderWidgetProps:
    def __init__(
        self,
        *,
        title: builtins.str,
        description: typing.Optional[builtins.str] = None,
        description_height: typing.Optional[jsii.Number] = None,
        family: typing.Optional[builtins.str] = None,
        go_to_link_url: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param title: 
        :param description: 
        :param description_height: 
        :param family: 
        :param go_to_link_url: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__205330df233bfe702239b5f2e913755a42ffd47938ea54ebf2a9aa812debe4a6)
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument description_height", value=description_height, expected_type=type_hints["description_height"])
            check_type(argname="argument family", value=family, expected_type=type_hints["family"])
            check_type(argname="argument go_to_link_url", value=go_to_link_url, expected_type=type_hints["go_to_link_url"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "title": title,
        }
        if description is not None:
            self._values["description"] = description
        if description_height is not None:
            self._values["description_height"] = description_height
        if family is not None:
            self._values["family"] = family
        if go_to_link_url is not None:
            self._values["go_to_link_url"] = go_to_link_url

    @builtins.property
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("title")
        assert result is not None, "Required property 'title' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description_height(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("description_height")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def family(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("family")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def go_to_link_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("go_to_link_url")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MonitoringHeaderWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MonitoringNamingStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MonitoringNamingStrategy",
):
    '''(experimental) Utility class to unify approach to naming monitoring sections.

    :see: https://docs.aws.amazon.com/cdk/latest/guide/tokens.html#tokens_lazy
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        fallback_construct_name: typing.Optional[builtins.str] = None,
        named_construct: typing.Optional[_constructs_77d1e7e8.IConstruct] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param fallback_construct_name: (experimental) Fallback name before we fallback to extracting name from the construct itself. This might be some construct reference, such is cluster ID, stream name, and so on. Default: - use namedConstruct to extract the name
        :param named_construct: (experimental) Construct that this naming strategy is naming. It is used as a last resort for naming.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :stability: experimental
        '''
        input = NameResolutionInput(
            fallback_construct_name=fallback_construct_name,
            named_construct=named_construct,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
        )

        jsii.create(self.__class__, self, [input])

    @jsii.member(jsii_name="isAlarmFriendly")
    @builtins.classmethod
    def is_alarm_friendly(
        cls,
        str: builtins.str,
    ) -> typing.Union[builtins.bool, builtins.str]:
        '''
        :param str: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b09b1f5d191cd8e787689163463f845e0d890bb82bed7a361c8f905b136ca4be)
            check_type(argname="argument str", value=str, expected_type=type_hints["str"])
        return typing.cast(typing.Union[builtins.bool, builtins.str], jsii.sinvoke(cls, "isAlarmFriendly", [str]))

    @jsii.member(jsii_name="resolveAlarmFriendlyName")
    def resolve_alarm_friendly_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "resolveAlarmFriendlyName", []))

    @jsii.member(jsii_name="resolveHumanReadableName")
    def resolve_human_readable_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "resolveHumanReadableName", []))

    @builtins.property
    @jsii.member(jsii_name="input")
    def _input(self) -> "NameResolutionInput":
        '''
        :stability: experimental
        '''
        return typing.cast("NameResolutionInput", jsii.get(self, "input"))


class MonitoringScope(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdk-monitoring-constructs.MonitoringScope",
):
    '''(experimental) A scope where all monitored constructs are managed from (i.e., alarms, dashboards, etc.).

    Standard usages will use {@link MonitoringFacade}.

    :stability: experimental
    '''

    def __init__(self, scope: _constructs_77d1e7e8.Construct, id: builtins.str) -> None:
        '''Creates a new construct node.

        :param scope: The scope in which to define this construct.
        :param id: The scoped construct ID. Must be unique amongst siblings. If the ID includes a path separator (``/``), then it will be replaced by double dash ``--``.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de511faae7c89568fed81eaa0ba4ef61b7e6333b7291fb5f9f8c3cda860b14a3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        jsii.create(self.__class__, self, [scope, id])

    @jsii.member(jsii_name="createAlarmFactory")
    @abc.abstractmethod
    def create_alarm_factory(self, alarm_name_prefix: builtins.str) -> AlarmFactory:
        '''(experimental) Creates a new alarm factory.

        Alarms created will be named with the given prefix, unless a local name override is present.

        :param alarm_name_prefix: alarm name prefix.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createAwsConsoleUrlFactory")
    @abc.abstractmethod
    def create_aws_console_url_factory(self) -> AwsConsoleUrlFactory:
        '''(experimental) Creates a new factory that creates AWS Console URLs.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createMetricFactory")
    @abc.abstractmethod
    def create_metric_factory(self) -> MetricFactory:
        '''(experimental) Creates a new metric factory.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createWidgetFactory")
    @abc.abstractmethod
    def create_widget_factory(self) -> IWidgetFactory:
        '''(experimental) Creates a new widget factory.

        :stability: experimental
        '''
        ...


class _MonitoringScopeProxy(MonitoringScope):
    @jsii.member(jsii_name="createAlarmFactory")
    def create_alarm_factory(self, alarm_name_prefix: builtins.str) -> AlarmFactory:
        '''(experimental) Creates a new alarm factory.

        Alarms created will be named with the given prefix, unless a local name override is present.

        :param alarm_name_prefix: alarm name prefix.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd385a9a7a83dc160515e6a3b722ef5fb7187d1edd59792b5a90673dc605c40c)
            check_type(argname="argument alarm_name_prefix", value=alarm_name_prefix, expected_type=type_hints["alarm_name_prefix"])
        return typing.cast(AlarmFactory, jsii.invoke(self, "createAlarmFactory", [alarm_name_prefix]))

    @jsii.member(jsii_name="createAwsConsoleUrlFactory")
    def create_aws_console_url_factory(self) -> AwsConsoleUrlFactory:
        '''(experimental) Creates a new factory that creates AWS Console URLs.

        :stability: experimental
        '''
        return typing.cast(AwsConsoleUrlFactory, jsii.invoke(self, "createAwsConsoleUrlFactory", []))

    @jsii.member(jsii_name="createMetricFactory")
    def create_metric_factory(self) -> MetricFactory:
        '''(experimental) Creates a new metric factory.

        :stability: experimental
        '''
        return typing.cast(MetricFactory, jsii.invoke(self, "createMetricFactory", []))

    @jsii.member(jsii_name="createWidgetFactory")
    def create_widget_factory(self) -> IWidgetFactory:
        '''(experimental) Creates a new widget factory.

        :stability: experimental
        '''
        return typing.cast(IWidgetFactory, jsii.invoke(self, "createWidgetFactory", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, MonitoringScope).__jsii_proxy_class__ = lambda : _MonitoringScopeProxy


@jsii.implements(IAlarmActionStrategy)
class MultipleAlarmActionStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MultipleAlarmActionStrategy",
):
    '''(experimental) Alarm action strategy that combines multiple actions in the same order as they were given.

    :stability: experimental
    '''

    def __init__(self, actions: typing.Sequence[IAlarmActionStrategy]) -> None:
        '''
        :param actions: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1009a27461c38955fada021253e70e1517e8683381e00c41ec1cb274bc948207)
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        jsii.create(self.__class__, self, [actions])

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmActionStrategyProps(
            alarm=alarm,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarmActions", [props]))

    @jsii.member(jsii_name="flattenedAlarmActions")
    def flattened_alarm_actions(self) -> typing.List[IAlarmActionStrategy]:
        '''(experimental) Returns list of alarm actions where any nested instances of MultipleAlarmActionStrategy are flattened.

        :return: flattened list of alarm actions.

        :stability: experimental
        '''
        return typing.cast(typing.List[IAlarmActionStrategy], jsii.invoke(self, "flattenedAlarmActions", []))

    @builtins.property
    @jsii.member(jsii_name="actions")
    def actions(self) -> typing.List[IAlarmActionStrategy]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[IAlarmActionStrategy], jsii.get(self, "actions"))


@jsii.implements(ILoadBalancerMetricFactory)
class NetworkLoadBalancerMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.NetworkLoadBalancerMetricFactory",
):
    '''(experimental) Metric factory to create metrics for network load-balanced service.

    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param network_load_balancer: 
        :param network_target_group: 
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38d536fd5ef6e758bbd4ac0ca5e2859bc4382a10b3434e8fb9b0024a60476b15)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = NetworkLoadBalancerMetricFactoryProps(
            network_load_balancer=network_load_balancer,
            network_target_group=network_target_group,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricActiveConnectionCount")
    def metric_active_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActiveConnectionCount", []))

    @jsii.member(jsii_name="metricHealthyTaskCount")
    def metric_healthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskCount", []))

    @jsii.member(jsii_name="metricHealthyTaskInPercent")
    def metric_healthy_task_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskInPercent", []))

    @jsii.member(jsii_name="metricNewConnectionCount")
    def metric_new_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNewConnectionCount", []))

    @jsii.member(jsii_name="metricProcessedBytesMin")
    def metric_processed_bytes_min(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProcessedBytesMin", []))

    @jsii.member(jsii_name="metricUnhealthyRoutingCount")
    def metric_unhealthy_routing_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyRoutingCount", []))

    @jsii.member(jsii_name="metricUnhealthyTaskCount")
    def metric_unhealthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyTaskCount", []))

    @builtins.property
    @jsii.member(jsii_name="invertStatisticsOfTaskCountEnabled")
    def _invert_statistics_of_task_count_enabled(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "invertStatisticsOfTaskCountEnabled"))

    @builtins.property
    @jsii.member(jsii_name="networkLoadBalancer")
    def _network_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer, jsii.get(self, "networkLoadBalancer"))

    @builtins.property
    @jsii.member(jsii_name="networkTargetGroup")
    def _network_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup, jsii.get(self, "networkTargetGroup"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.NetworkLoadBalancerMetricFactoryProps",
    jsii_struct_bases=[BaseLoadBalancerMetricFactoryProps, BaseMetricFactoryProps],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "network_load_balancer": "networkLoadBalancer",
        "network_target_group": "networkTargetGroup",
    },
)
class NetworkLoadBalancerMetricFactoryProps(
    BaseLoadBalancerMetricFactoryProps,
    BaseMetricFactoryProps,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    ) -> None:
        '''(experimental) Props to create NetworkLoadBalancerMetricFactory.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param network_load_balancer: 
        :param network_target_group: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7eec06d575009bc57ad27e91dfd1f4de9c39fda039bdc3f4e44a7f353eafc2c4)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument network_load_balancer", value=network_load_balancer, expected_type=type_hints["network_load_balancer"])
            check_type(argname="argument network_target_group", value=network_target_group, expected_type=type_hints["network_target_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_load_balancer": network_load_balancer,
            "network_target_group": network_target_group,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_load_balancer")
        assert result is not None, "Required property 'network_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer, result)

    @builtins.property
    def network_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_target_group")
        assert result is not None, "Required property 'network_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NetworkLoadBalancerMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class NetworkLoadBalancerMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.NetworkLoadBalancerMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UnhealthyTaskCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param network_load_balancer: 
        :param network_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35376777fd4b34298f767673143427e2a3257d10aed099ed6d3ff925d78a4099)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = NetworkLoadBalancerMonitoringProps(
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            network_load_balancer=network_load_balancer,
            network_target_group=network_target_group,
            use_created_alarms=use_created_alarms,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createTaskHealthWidget")
    def _create_task_health_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__214e33afc094333bb1bb8e85fd453f383093947262053f56f937351682b7c119)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTaskHealthWidget", [width, height]))

    @jsii.member(jsii_name="createTcpFlowsWidget")
    def _create_tcp_flows_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c5e9d1ba2069fa46706876a01bcde7e319740f572418f1ae2b1d2d9af643a9ec)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTcpFlowsWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def _create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="activeTcpFlowCountMetric")
    def _active_tcp_flow_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "activeTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskCountMetric")
    def _healthy_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "healthyTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskPercentMetric")
    def _healthy_task_percent_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "healthyTaskPercentMetric"))

    @builtins.property
    @jsii.member(jsii_name="humanReadableName")
    def _human_readable_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "humanReadableName"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def _metric_factory(self) -> NetworkLoadBalancerMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(NetworkLoadBalancerMetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="newTcpFlowCountMetric")
    def _new_tcp_flow_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "newTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesAnnotations")
    def _processed_bytes_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "processedBytesAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesMetric")
    def _processed_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "processedBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAlarmFactory")
    def _task_health_alarm_factory(self) -> "TaskHealthAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("TaskHealthAlarmFactory", jsii.get(self, "taskHealthAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAnnotations")
    def _task_health_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "taskHealthAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="throughputAlarmFactory")
    def _throughput_alarm_factory(self) -> "ThroughputAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("ThroughputAlarmFactory", jsii.get(self, "throughputAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyRoutingFlowCountMetric")
    def _unhealthy_routing_flow_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "unhealthyRoutingFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyTaskCountMetric")
    def _unhealthy_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "unhealthyTaskCountMetric"))


@jsii.implements(IAlarmActionStrategy)
class NoopAlarmActionStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.NoopAlarmActionStrategy",
):
    '''(experimental) Alarm action strategy that does not add any actions.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        _props = AlarmActionStrategyProps(
            alarm=alarm,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarmActions", [_props]))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.NotificationsFailedThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_notifications_failed_count": "maxNotificationsFailedCount",
    },
)
class NotificationsFailedThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_notifications_failed_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_notifications_failed_count: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e2bae971dc5eb03e121443ef75bb1cea6396f632ba6a6dcf24146ecc8dd6acc)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_notifications_failed_count", value=max_notifications_failed_count, expected_type=type_hints["max_notifications_failed_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_notifications_failed_count": max_notifications_failed_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_notifications_failed_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_notifications_failed_count")
        assert result is not None, "Required property 'max_notifications_failed_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NotificationsFailedThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class OpenSearchBackportedMetrics(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.OpenSearchBackportedMetrics",
):
    '''(experimental) Backported set of metric functions added in @aws-cdk/aws-elasticsearch@1.65.0.

    :see: https://github.com/aws/aws-cdk/releases/tag/v1.73.0
    :stability: experimental
    '''

    def __init__(
        self,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
    ) -> None:
        '''
        :param domain: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__315dd7ab3935330444ce7108bcc350c0f76202dbd5201f278518637a8ad9326a)
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
        jsii.create(self.__class__, self, [domain])

    @jsii.member(jsii_name="metric")
    def metric(
        self,
        metric_name: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Return the given named metric for this Domain.

        :param metric_name: -
        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__80d9d0eddf06c2b9f82e9100e43901436dae7b2a2d08a843152438517bcfed1c)
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metric", [metric_name, props]))

    @jsii.member(jsii_name="metricAutomatedSnapshotFailure")
    def metric_automated_snapshot_failure(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for automated snapshot failures.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricAutomatedSnapshotFailure", [props]))

    @jsii.member(jsii_name="metricClusterIndexWriteBlocked")
    def metric_cluster_index_write_blocked(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(deprecated) Metric for the cluster blocking index writes.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 1 minute

        :deprecated: use metricClusterIndexWritesBlocked instead.

        :stability: deprecated
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricClusterIndexWriteBlocked", [props]))

    @jsii.member(jsii_name="metricClusterIndexWritesBlocked")
    def metric_cluster_index_writes_blocked(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for the cluster blocking index writes.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 1 minute

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricClusterIndexWritesBlocked", [props]))

    @jsii.member(jsii_name="metricClusterStatusRed")
    def metric_cluster_status_red(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for the time the cluster status is red.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricClusterStatusRed", [props]))

    @jsii.member(jsii_name="metricClusterStatusYellow")
    def metric_cluster_status_yellow(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for the time the cluster status is yellow.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricClusterStatusYellow", [props]))

    @jsii.member(jsii_name="metricCPUUtilization")
    def metric_cpu_utilization(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for CPU utilization.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricCPUUtilization", [props]))

    @jsii.member(jsii_name="metricFreeStorageSpace")
    def metric_free_storage_space(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for the storage space of nodes in the cluster.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - minimum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricFreeStorageSpace", [props]))

    @jsii.member(jsii_name="metricIndexingLatency")
    def metric_indexing_latency(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for indexing latency.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - p99 over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricIndexingLatency", [props]))

    @jsii.member(jsii_name="metricJVMMemoryPressure")
    def metric_jvm_memory_pressure(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for JVM memory pressure.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricJVMMemoryPressure", [props]))

    @jsii.member(jsii_name="metricKMSKeyError")
    def metric_kms_key_error(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for KMS key errors.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricKMSKeyError", [props]))

    @jsii.member(jsii_name="metricKMSKeyInaccessible")
    def metric_kms_key_inaccessible(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for KMS key being inaccessible.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricKMSKeyInaccessible", [props]))

    @jsii.member(jsii_name="metricMasterCPUUtilization")
    def metric_master_cpu_utilization(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for master CPU utilization.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricMasterCPUUtilization", [props]))

    @jsii.member(jsii_name="metricMasterJVMMemoryPressure")
    def metric_master_jvm_memory_pressure(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for master JVM memory pressure.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricMasterJVMMemoryPressure", [props]))

    @jsii.member(jsii_name="metricNodes")
    def metric_nodes(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for the number of nodes.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - minimum over 1 hour

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricNodes", [props]))

    @jsii.member(jsii_name="metricSearchableDocuments")
    def metric_searchable_documents(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for number of searchable documents.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - maximum over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricSearchableDocuments", [props]))

    @jsii.member(jsii_name="metricSearchLatency")
    def metric_search_latency(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''(experimental) Metric for search latency.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: - p99 over 5 minutes

        :stability: experimental
        '''
        props = _aws_cdk_aws_cloudwatch_ceddda9d.MetricOptions(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricSearchLatency", [props]))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


class OpenSearchClusterAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57edfc7c5ec3b6bf57f1ad80dfb371d230cbb589697e125e597b19d57d60ca3d)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addAutomatedSnapshotFailureAlarm")
    def add_automated_snapshot_failure_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchClusterAutomatedSnapshotFailureThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4222857ad5e5addae3c0ac2d3d8c4f21df08b2cef18ebb39c8909735617d7caf)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addAutomatedSnapshotFailureAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addClusterIndexWritesBlockedAlarm")
    def add_cluster_index_writes_blocked_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchClusterIndexWritesBlockedThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96f98b934af9ba6c2c97bac53a10b60c492c18e89e82a8ec1e87a0a7b6ad1a29)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addClusterIndexWritesBlockedAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addClusterNodeCountAlarm")
    def add_cluster_node_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchClusterNodesThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__afaa25398d400d3e6a13a5a7c7e53370e7731919d8dc70c2c0365661651fae3e)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addClusterNodeCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addClusterStatusAlarm")
    def add_cluster_status_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchClusterStatusCustomization", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f9e0176dccec25279501dab4b551906455b7b2f7276ee7068d9ada81b0b72ab)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addClusterStatusAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addKmsKeyErrorAlarm")
    def add_kms_key_error_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchKmsKeyErrorThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a8fcb3bb428f198e295e205a3a921bc996225791233ba57abf09179f3e6f5cd0)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addKmsKeyErrorAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addKmsKeyInaccessibleAlarm")
    def add_kms_key_inaccessible_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["OpenSearchKmsKeyInaccessibleThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6c9f69b29063713182510809f226bce441b88bd1bfafaac0680059f9f9417ea)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addKmsKeyInaccessibleAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterAutomatedSnapshotFailureThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_failures": "maxFailures",
    },
)
class OpenSearchClusterAutomatedSnapshotFailureThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_failures: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_failures: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c824343009a905b4142a504d4789282fd725dbe7a660597a0b7c441bc15888ec)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_failures", value=max_failures, expected_type=type_hints["max_failures"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_failures": max_failures,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_failures(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_failures")
        assert result is not None, "Required property 'max_failures' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterAutomatedSnapshotFailureThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterIndexWritesBlockedThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_blocked_writes": "maxBlockedWrites",
    },
)
class OpenSearchClusterIndexWritesBlockedThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_blocked_writes: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_blocked_writes: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58f4591dfa92ce45813ecad65c208f6ac00e3a87310078d33dd39823bedbb39c)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_blocked_writes", value=max_blocked_writes, expected_type=type_hints["max_blocked_writes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_blocked_writes": max_blocked_writes,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_blocked_writes(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_blocked_writes")
        assert result is not None, "Required property 'max_blocked_writes' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterIndexWritesBlockedThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class OpenSearchClusterMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__edb80488c11f669647af177f6a06a825f7e9392abcc3e5214a58953d9fe9629a)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = OpenSearchClusterMetricFactoryProps(
            domain=domain,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAutomatedSnapshotFailure")
    def metric_automated_snapshot_failure(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAutomatedSnapshotFailure", []))

    @jsii.member(jsii_name="metricClusterIndexWriteBlocked")
    def metric_cluster_index_write_blocked(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricClusterIndexWritesBlocked instead

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterIndexWriteBlocked", []))

    @jsii.member(jsii_name="metricClusterIndexWritesBlocked")
    def metric_cluster_index_writes_blocked(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterIndexWritesBlocked", []))

    @jsii.member(jsii_name="metricClusterStatusRed")
    def metric_cluster_status_red(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterStatusRed", []))

    @jsii.member(jsii_name="metricClusterStatusYellow")
    def metric_cluster_status_yellow(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricClusterStatusYellow", []))

    @jsii.member(jsii_name="metricCpuUsage")
    def metric_cpu_usage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCpuUsage", []))

    @jsii.member(jsii_name="metricDiskSpaceUsageInPercent")
    def metric_disk_space_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDiskSpaceUsageInPercent", []))

    @jsii.member(jsii_name="metricIndexingLatencyP50InMillis")
    def metric_indexing_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIndexingLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricIndexingLatencyP90InMillis")
    def metric_indexing_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIndexingLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricIndexingLatencyP99InMillis")
    def metric_indexing_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIndexingLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricJvmMemoryPressure")
    def metric_jvm_memory_pressure(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricJvmMemoryPressure", []))

    @jsii.member(jsii_name="metricKmsKeyError")
    def metric_kms_key_error(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricKmsKeyError", []))

    @jsii.member(jsii_name="metricKmsKeyInaccessible")
    def metric_kms_key_inaccessible(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricKmsKeyInaccessible", []))

    @jsii.member(jsii_name="metricMasterCpuUsage")
    def metric_master_cpu_usage(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMasterCpuUsage", []))

    @jsii.member(jsii_name="metricMasterJvmMemoryPressure")
    def metric_master_jvm_memory_pressure(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMasterJvmMemoryPressure", []))

    @jsii.member(jsii_name="metricNodes")
    def metric_nodes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNodes", []))

    @jsii.member(jsii_name="metricSearchCount")
    def metric_search_count(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.Metric:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Metric, jsii.invoke(self, "metricSearchCount", []))

    @jsii.member(jsii_name="metricSearchLatencyP50InMillis")
    def metric_search_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSearchLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricSearchLatencyP90InMillis")
    def metric_search_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSearchLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricSearchLatencyP99InMillis")
    def metric_search_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSearchLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricSearchRate")
    def metric_search_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSearchRate", []))

    @jsii.member(jsii_name="metricTps")
    def metric_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricSearchRate

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTps", []))

    @builtins.property
    @jsii.member(jsii_name="domainMetrics")
    def _domain_metrics(self) -> OpenSearchBackportedMetrics:
        '''
        :stability: experimental
        '''
        return typing.cast(OpenSearchBackportedMetrics, jsii.get(self, "domainMetrics"))

    @builtins.property
    @jsii.member(jsii_name="fillTpsWithZeroes")
    def _fill_tps_with_zeroes(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "fillTpsWithZeroes"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> "RateComputationMethod":
        '''
        :stability: experimental
        '''
        return typing.cast("RateComputationMethod", jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "domain": "domain",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class OpenSearchClusterMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d7bd8a2864ab2bea095b2b1bbd29a11ee6cc6ecf2652f29b5fbfe39c3b019e12)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "domain": domain,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def domain(
        self,
    ) -> typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain]:
        '''
        :stability: experimental
        '''
        result = self._values.get("domain")
        assert result is not None, "Required property 'domain' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional["RateComputationMethod"]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional["RateComputationMethod"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class OpenSearchClusterMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional["RateComputationMethod"] = None,
        add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["OpenSearchClusterNodesThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["OpenSearchClusterStatusCustomization", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["OpenSearchKmsKeyErrorThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["OpenSearchKmsKeyInaccessibleThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add_cluster_automated_snapshot_failure_alarm: 
        :param add_cluster_index_writes_blocked_alarm: 
        :param add_cluster_node_count_alarm: 
        :param add_cluster_status_alarm: 
        :param add_cpu_space_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_indexing_latency_p50_alarm: 
        :param add_indexing_latency_p90_alarm: 
        :param add_indexing_latency_p99_alarm: 
        :param add_jvm_memory_pressure_alarm: 
        :param add_kms_key_error_alarm: 
        :param add_kms_key_inaccessible_alarm: 
        :param add_master_cpu_space_usage_alarm: 
        :param add_master_jvm_memory_pressure_alarm: 
        :param add_search_latency_p50_alarm: 
        :param add_search_latency_p90_alarm: 
        :param add_search_latency_p99_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d5ae6732d6b6c075d18656168a7b5351e10eafd44ed610aef6295343b126fa38)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = OpenSearchClusterMonitoringProps(
            domain=domain,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add_cluster_automated_snapshot_failure_alarm=add_cluster_automated_snapshot_failure_alarm,
            add_cluster_index_writes_blocked_alarm=add_cluster_index_writes_blocked_alarm,
            add_cluster_node_count_alarm=add_cluster_node_count_alarm,
            add_cluster_status_alarm=add_cluster_status_alarm,
            add_cpu_space_usage_alarm=add_cpu_space_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_indexing_latency_p50_alarm=add_indexing_latency_p50_alarm,
            add_indexing_latency_p90_alarm=add_indexing_latency_p90_alarm,
            add_indexing_latency_p99_alarm=add_indexing_latency_p99_alarm,
            add_jvm_memory_pressure_alarm=add_jvm_memory_pressure_alarm,
            add_kms_key_error_alarm=add_kms_key_error_alarm,
            add_kms_key_inaccessible_alarm=add_kms_key_inaccessible_alarm,
            add_master_cpu_space_usage_alarm=add_master_cpu_space_usage_alarm,
            add_master_jvm_memory_pressure_alarm=add_master_jvm_memory_pressure_alarm,
            add_search_latency_p50_alarm=add_search_latency_p50_alarm,
            add_search_latency_p90_alarm=add_search_latency_p90_alarm,
            add_search_latency_p99_alarm=add_search_latency_p99_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="automatedSnapshotFailureMetric")
    def automated_snapshot_failure_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "automatedSnapshotFailureMetric"))

    @builtins.property
    @jsii.member(jsii_name="clusterAlarmFactory")
    def cluster_alarm_factory(self) -> OpenSearchClusterAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(OpenSearchClusterAlarmFactory, jsii.get(self, "clusterAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="clusterAnnotations")
    def cluster_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "clusterAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="clusterStatusRedMetric")
    def cluster_status_red_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "clusterStatusRedMetric"))

    @builtins.property
    @jsii.member(jsii_name="clusterStatusYellowMetric")
    def cluster_status_yellow_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "clusterStatusYellowMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="diskSpaceUsageMetric")
    def disk_space_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "diskSpaceUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="indexingLatencyAlarmFactory")
    def indexing_latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "indexingLatencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="indexingLatencyAnnotations")
    def indexing_latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "indexingLatencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="indexWriteBlockedMetric")
    def index_write_blocked_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "indexWriteBlockedMetric"))

    @builtins.property
    @jsii.member(jsii_name="jvmMemoryPressureMetric")
    def jvm_memory_pressure_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "jvmMemoryPressureMetric"))

    @builtins.property
    @jsii.member(jsii_name="kmsKeyErrorMetric")
    def kms_key_error_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "kmsKeyErrorMetric"))

    @builtins.property
    @jsii.member(jsii_name="kmsKeyInaccessibleMetric")
    def kms_key_inaccessible_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "kmsKeyInaccessibleMetric"))

    @builtins.property
    @jsii.member(jsii_name="masterCpuUsageMetric")
    def master_cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "masterCpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="masterJvmMemoryPressureMetric")
    def master_jvm_memory_pressure_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "masterJvmMemoryPressureMetric"))

    @builtins.property
    @jsii.member(jsii_name="masterUsageAnnotations")
    def master_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "masterUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="nodeAnnotations")
    def node_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "nodeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="nodesMetric")
    def nodes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "nodesMetric"))

    @builtins.property
    @jsii.member(jsii_name="p50IndexingLatencyMetric")
    def p50_indexing_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50IndexingLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p50SearchLatencyMetric")
    def p50_search_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50SearchLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90IndexingLatencyMetric")
    def p90_indexing_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90IndexingLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90SearchLatencyMetric")
    def p90_search_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90SearchLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99IndexingLatencyMetric")
    def p99_indexing_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99IndexingLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99SearchLatencyMetric")
    def p99_search_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99SearchLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="searchLatencyAlarmFactory")
    def search_latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "searchLatencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="searchLatencyAnnotations")
    def search_latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "searchLatencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> "UsageAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("UsageAlarmFactory", jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterNodesThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_nodes": "minNodes",
    },
)
class OpenSearchClusterNodesThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_nodes: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_nodes: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36a18ce2f05eec38f0c69162425d6ff347ac76d6c6d83e52dcd465d995144238)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_nodes", value=min_nodes, expected_type=type_hints["min_nodes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_nodes": min_nodes,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_nodes(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_nodes")
        assert result is not None, "Required property 'min_nodes' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterNodesThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.OpenSearchClusterStatus")
class OpenSearchClusterStatus(enum.Enum):
    '''
    :stability: experimental
    '''

    RED = "RED"
    '''
    :stability: experimental
    '''
    YELLOW = "YELLOW"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterStatusCustomization",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "status": "status",
    },
)
class OpenSearchClusterStatusCustomization(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        status: typing.Union[OpenSearchClusterStatus, ElasticsearchClusterStatus],
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param status: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0efb3bb54f27e195961602f31559e6117a91b9960cd94b1348aa20bc2e69c541)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument status", value=status, expected_type=type_hints["status"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "status": status,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def status(
        self,
    ) -> typing.Union[OpenSearchClusterStatus, ElasticsearchClusterStatus]:
        '''
        :stability: experimental
        '''
        result = self._values.get("status")
        assert result is not None, "Required property 'status' is missing"
        return typing.cast(typing.Union[OpenSearchClusterStatus, ElasticsearchClusterStatus], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterStatusCustomization(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchKmsKeyErrorThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_errors": "maxErrors",
    },
)
class OpenSearchKmsKeyErrorThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_errors: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_errors: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3eeeaeb925a6417103061edf178b6bb16203b9e9c13f8b1b8669091768fbce15)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_errors", value=max_errors, expected_type=type_hints["max_errors"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_errors": max_errors,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_errors(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_errors")
        assert result is not None, "Required property 'max_errors' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchKmsKeyErrorThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchKmsKeyInaccessibleThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_access_attempts": "maxAccessAttempts",
    },
)
class OpenSearchKmsKeyInaccessibleThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_access_attempts: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_access_attempts: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca90b7793b13ee17159fe4688a54a129222f7d2da81e0ac774a68fdc410997aa)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_access_attempts", value=max_access_attempts, expected_type=type_hints["max_access_attempts"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_access_attempts": max_access_attempts,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_access_attempts(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_access_attempts")
        assert result is not None, "Required property 'max_access_attempts' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchKmsKeyInaccessibleThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IAlarmActionStrategy)
class OpsItemAlarmActionStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.OpsItemAlarmActionStrategy",
):
    '''(experimental) Alarm action strategy that creates an AWS OpsCenter OpsItem.

    :stability: experimental
    '''

    def __init__(
        self,
        severity: _aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemSeverity,
        category: typing.Optional[_aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemCategory] = None,
    ) -> None:
        '''
        :param severity: -
        :param category: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8fda195786fefae2bd77bd655869de1891d8c007382c2613b4c747ec31d0f2c)
            check_type(argname="argument severity", value=severity, expected_type=type_hints["severity"])
            check_type(argname="argument category", value=category, expected_type=type_hints["category"])
        jsii.create(self.__class__, self, [severity, category])

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmActionStrategyProps(
            alarm=alarm,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarmActions", [props]))

    @builtins.property
    @jsii.member(jsii_name="severity")
    def severity(self) -> _aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemSeverity:
        '''(experimental) OPS Item Severity.

        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemSeverity, jsii.get(self, "severity"))

    @builtins.property
    @jsii.member(jsii_name="category")
    def category(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemCategory]:
        '''(experimental) OPS Item Category.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemCategory], jsii.get(self, "category"))


class QueueAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.QueueAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3610dca69ddae6cedb06be1dc707427ee111ce931f9e662a2ba679fb7ec0af7b)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxQueueIncomingMessagesCountAlarm")
    def add_max_queue_incoming_messages_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2fe3f47d612779158e450e8df217cec4d747cb79ff3e8449b6cb16f70db9a44c)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxQueueIncomingMessagesCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxQueueMessageAgeAlarm")
    def add_max_queue_message_age_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd1e631f010e81728e322991e30714f576316075992cad9f8fc1148f4ba3832e)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxQueueMessageAgeAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxQueueMessageCountAlarm")
    def add_max_queue_message_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf5fc5cedaba9e2572914b5168e11bde28e6f730c9ee5cb0bdb27d2f6d0d85a5)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxQueueMessageCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxQueueTimeToDrainMessagesAlarm")
    def add_max_queue_time_to_drain_messages_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4be668496dcd363e865296a3783c20f706dcaa4eab2db216347b3c5785712002)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxQueueTimeToDrainMessagesAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinQueueIncomingMessagesCountAlarm")
    def add_min_queue_incoming_messages_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb2615482f6aaaffb7055d5c1c46314d31caa045f98d49c8fd50804f738a98dd)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinQueueIncomingMessagesCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinQueueMessageCountAlarm")
    def add_min_queue_message_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4fb87d3a7e3b5ece036e653c2fb9558d43ee99c0d9f464521b7f4c6642f2d172)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinQueueMessageCountAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.enum(jsii_type="cdk-monitoring-constructs.RateComputationMethod")
class RateComputationMethod(enum.Enum):
    '''(experimental) Enumeration of different rate computation methods.

    :stability: experimental
    '''

    AVERAGE = "AVERAGE"
    '''(experimental) Number of occurrences relative to requests.

    Less sensitive than per-second when TPS > 1.

    :stability: experimental
    '''
    PER_SECOND = "PER_SECOND"
    '''(experimental) Number of occurrences per second.

    More sensitive than average when TPS > 1.

    :stability: experimental
    '''
    PER_MINUTE = "PER_MINUTE"
    '''(experimental) Number of occurrences per minute.

    :stability: experimental
    '''
    PER_HOUR = "PER_HOUR"
    '''(experimental) Number of occurrences per hour.

    :stability: experimental
    '''
    PER_DAY = "PER_DAY"
    '''(experimental) Number of occurrences per day.

    :stability: experimental
    '''


class RdsClusterMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RdsClusterMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0378c3527a01f7fd49284a42b8daf12733e01204fa288a846a1cbb8d50c223b)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = RdsClusterMetricFactoryProps(
            cluster=cluster,
            cluster_identifier=cluster_identifier,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCpuUsageInPercent")
    def metric_average_cpu_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageCpuUsageInPercent", []))

    @jsii.member(jsii_name="metricCommitLatencyP90InMillis")
    def metric_commit_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricCommitLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricDeleteLatencyP90InMillis")
    def metric_delete_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDeleteLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricDiskSpaceUsageInPercent")
    def metric_disk_space_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDiskSpaceUsageInPercent", []))

    @jsii.member(jsii_name="metricFreeStorageInBytes")
    def metric_free_storage_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFreeStorageInBytes", []))

    @jsii.member(jsii_name="metricInsertLatencyP90InMillis")
    def metric_insert_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInsertLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricSelectLatencyP90InMillis")
    def metric_select_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSelectLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricServerlessDatabaseCapacity")
    def metric_serverless_database_capacity(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServerlessDatabaseCapacity", []))

    @jsii.member(jsii_name="metricTotalConnectionCount")
    def metric_total_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalConnectionCount", []))

    @jsii.member(jsii_name="metricUpdateLatencyP90InMillis")
    def metric_update_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUpdateLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricUsedStorageInBytes")
    def metric_used_storage_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUsedStorageInBytes", []))

    @builtins.property
    @jsii.member(jsii_name="clusterIdentifier")
    def cluster_identifier(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "clusterIdentifier"))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="cluster")
    def cluster(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]], jsii.get(self, "cluster"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsClusterMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster": "cluster",
        "cluster_identifier": "clusterIdentifier",
    },
)
class RdsClusterMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab560729798f84db3b95041118dd4a433aa9f9ae2b104ea11db142deb50b1452)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
            check_type(argname="argument cluster_identifier", value=cluster_identifier, expected_type=type_hints["cluster_identifier"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if cluster is not None:
            self._values["cluster"] = cluster
        if cluster_identifier is not None:
            self._values["cluster_identifier"] = cluster_identifier

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]]:
        '''(experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).

        :stability: experimental
        '''
        result = self._values.get("cluster")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]], result)

    @builtins.property
    def cluster_identifier(self) -> typing.Optional[builtins.str]:
        '''(deprecated) database cluster identifier (either this or ``cluster`` need to be specified).

        :deprecated: please use ``cluster`` instead

        :stability: deprecated
        '''
        result = self._values.get("cluster_identifier")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsClusterMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class RdsClusterMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RdsClusterMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7bbba1d3a4b28f5dd027f879085a71a1607012edee0dc89f5a08793138cb01d2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = RdsClusterMonitoringProps(
            cluster=cluster,
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4143dca6c6d54027594284ca458150d17a8ae0ca3c973ad8abb7a97141350215)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createCpuAndDiskUsageWidget")
    def create_cpu_and_disk_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86cbedfd44483a9ff3c33ea1c21435c6fcf6adeea3135a751d586749b9167fca)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuAndDiskUsageWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c1b0995fe263c3c350a9074b0736952f913c59278506136a784aefe7ef02be2)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="commitLatencyMetric")
    def commit_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "commitLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="connectionAlarmFactory")
    def connection_alarm_factory(self) -> ConnectionAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ConnectionAlarmFactory, jsii.get(self, "connectionAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="connectionAnnotations")
    def connection_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "connectionAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="deleteLatencyMetric")
    def delete_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deleteLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="diskSpaceUsageMetric")
    def disk_space_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "diskSpaceUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="insertLatencyMetric")
    def insert_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "insertLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="selectLatencyMetric")
    def select_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "selectLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="updateLatencyMetric")
    def update_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "updateLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> "UsageAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("UsageAlarmFactory", jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


class RdsInstanceMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RdsInstanceMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param instance: (experimental) database instance.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1280b2f346c922ed3a716b059c1bc7b636ee4051325ff957798e14e5b394595b)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = RdsInstanceMetricFactoryProps(
            instance=instance, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCpuUsageInPercent")
    def metric_average_cpu_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageCpuUsageInPercent", []))

    @jsii.member(jsii_name="metricAverageFreeableMemory")
    def metric_average_freeable_memory(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageFreeableMemory", []))

    @jsii.member(jsii_name="metricMaxFreeStorageSpace")
    def metric_max_free_storage_space(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaxFreeStorageSpace", []))

    @jsii.member(jsii_name="metricReadIops")
    def metric_read_iops(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadIops", []))

    @jsii.member(jsii_name="metricReadLatencyInMillis")
    def metric_read_latency_in_millis(
        self,
        latency_type: LatencyType,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53f6ed947bb2da80961b319b8b25dd6792c4ba419ffb0ee7a511383e47930c86)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricReadThroughput")
    def metric_read_throughput(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadThroughput", []))

    @jsii.member(jsii_name="metricTotalConnectionCount")
    def metric_total_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalConnectionCount", []))

    @jsii.member(jsii_name="metricWriteIops")
    def metric_write_iops(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteIops", []))

    @jsii.member(jsii_name="metricWriteLatencyInMillis")
    def metric_write_latency_in_millis(
        self,
        latency_type: LatencyType,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e464b13caa903c703173ec6f96ac13dc968e11dd34f3869d1814906d3fb2eabb)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricWriteThroughput")
    def metric_write_throughput(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteThroughput", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="instance")
    def instance(self) -> _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance, jsii.get(self, "instance"))

    @builtins.property
    @jsii.member(jsii_name="instanceIdentifier")
    def instance_identifier(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceIdentifier"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsInstanceMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "instance": "instance"},
)
class RdsInstanceMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param instance: (experimental) database instance.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__caf9403cc98950c23a7dc94c7a5d8be8be4ea67810756e2610831e3fd9e52c32)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance": instance,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance(self) -> _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance:
        '''(experimental) database instance.

        :stability: experimental
        '''
        result = self._values.get("instance")
        assert result is not None, "Required property 'instance' is missing"
        return typing.cast(_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsInstanceMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class RdsInstanceMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RdsInstanceMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param instance: (experimental) database instance.
        :param add_cpu_usage_alarm: 
        :param add_free_storage_space_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa3ba27a2df4940defefb8d1848b3d89eb9cfb573657dde7e4630390d01d4116)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = RdsInstanceMonitoringProps(
            instance=instance,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_free_storage_space_alarm=add_free_storage_space_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76ba205cb9719c80e6579a6883ef77995813bfc9694d8448e75e3f4468ce0267)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createCpuAndDiskUsageWidget")
    def create_cpu_and_disk_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__65c37ff8fe077720eff47b5d6e1762a5686b2670fac2af107c58bc11e0e1672a)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuAndDiskUsageWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eaad3c626963c692a464765dd76b596818bca9059c9e8a54a6c8d6398c2dca17)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="connectionAlarmFactory")
    def connection_alarm_factory(self) -> ConnectionAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ConnectionAlarmFactory, jsii.get(self, "connectionAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="connectionAnnotations")
    def connection_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "connectionAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="freeableMemoryMetric")
    def freeable_memory_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "freeableMemoryMetric"))

    @builtins.property
    @jsii.member(jsii_name="freeStorageSpaceMetric")
    def free_storage_space_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "freeStorageSpaceMetric"))

    @builtins.property
    @jsii.member(jsii_name="readIopsMetric")
    def read_iops_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readIopsMetric"))

    @builtins.property
    @jsii.member(jsii_name="readLatencyMetric")
    def read_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="readThroughputMetric")
    def read_throughput_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readThroughputMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> "UsageAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("UsageAlarmFactory", jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="writeIopsMetric")
    def write_iops_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeIopsMetric"))

    @builtins.property
    @jsii.member(jsii_name="writeLatencyMetric")
    def write_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="writeThroughputMetric")
    def write_throughput_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeThroughputMetric"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RecordsFailedThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_records_failed_threshold": "maxRecordsFailedThreshold",
    },
)
class RecordsFailedThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_records_failed_threshold: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_records_failed_threshold: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7182322cc8a79ca5194e326a200e2540bdf8f40a890e18790608e2be8b421b1)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_records_failed_threshold", value=max_records_failed_threshold, expected_type=type_hints["max_records_failed_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_records_failed_threshold": max_records_failed_threshold,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_records_failed_threshold(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_records_failed_threshold")
        assert result is not None, "Required property 'max_records_failed_threshold' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RecordsFailedThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RecordsThrottledThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_records_throttled_threshold": "maxRecordsThrottledThreshold",
    },
)
class RecordsThrottledThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_records_throttled_threshold: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_records_throttled_threshold: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b3f01ba850bece07559600720099f762fd6040516923fea535c3d09e3a68752)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_records_throttled_threshold", value=max_records_throttled_threshold, expected_type=type_hints["max_records_throttled_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_records_throttled_threshold": max_records_throttled_threshold,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_records_throttled_threshold(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_records_throttled_threshold")
        assert result is not None, "Required property 'max_records_throttled_threshold' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RecordsThrottledThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class RedshiftClusterMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RedshiftClusterMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        cluster_identifier: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param cluster_identifier: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b387c2982450663260be582b01c1cb8c775e8927c02b9cf22abac1b502c19a38)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = RedshiftClusterMetricFactoryProps(
            cluster_identifier=cluster_identifier, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageCpuUsageInPercent")
    def metric_average_cpu_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageCpuUsageInPercent", []))

    @jsii.member(jsii_name="metricAverageDiskSpaceUsageInPercent")
    def metric_average_disk_space_usage_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageDiskSpaceUsageInPercent", []))

    @jsii.member(jsii_name="metricLongQueryDurationP90InMillis")
    def metric_long_query_duration_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLongQueryDurationP90InMillis", []))

    @jsii.member(jsii_name="metricMaintenanceModeEnabled")
    def metric_maintenance_mode_enabled(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMaintenanceModeEnabled", []))

    @jsii.member(jsii_name="metricMediumQueryDurationP90InMillis")
    def metric_medium_query_duration_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricMediumQueryDurationP90InMillis", []))

    @jsii.member(jsii_name="metricReadLatencyP90InMillis")
    def metric_read_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricReadLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricShortQueryDurationP90InMillis")
    def metric_short_query_duration_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricShortQueryDurationP90InMillis", []))

    @jsii.member(jsii_name="metricTotalConnectionCount")
    def metric_total_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTotalConnectionCount", []))

    @jsii.member(jsii_name="metricWriteLatencyP90InMillis")
    def metric_write_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricWriteLatencyP90InMillis", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RedshiftClusterMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster_identifier": "clusterIdentifier",
    },
)
class RedshiftClusterMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster_identifier: builtins.str,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster_identifier: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9107c196ac9343509ccba301127e0768c4a45251cbbcbb4eff9199dbcbeea1b)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster_identifier", value=cluster_identifier, expected_type=type_hints["cluster_identifier"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster_identifier": cluster_identifier,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster_identifier(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("cluster_identifier")
        assert result is not None, "Required property 'cluster_identifier' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RedshiftClusterMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class RedshiftClusterMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.RedshiftClusterMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        cluster_identifier: builtins.str,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param cluster_identifier: 
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_long_query_duration_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de9377c4a8cd037f51e3426910d2cd79ca19b26e7108aedefcc7c032fe8dbfff)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = RedshiftClusterMonitoringProps(
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_max_long_query_duration_alarm=add_max_long_query_duration_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__94ae75930b4b2ac3eac5d4296fcb43c7ee36e288701a0b663bf2f8467093a010)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createCpuAndDiskUsageWidget")
    def create_cpu_and_disk_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bfde043368b124871e2c1c8f72410366045b89c2909a849b000e85f704f7d006)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuAndDiskUsageWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ca63050b6bad8765d8c4c4892f23ac2046af2c5339ba91e1524a72a5dd1ecd0)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createMaintenanceWidget")
    def create_maintenance_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d653ab58379bc849d25c1c7a3b105bafc709597df0c39ce25d309d69d7fe6a8a)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMaintenanceWidget", [width, height]))

    @jsii.member(jsii_name="createQueryDurationWidget")
    def create_query_duration_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__33f45b92ebd4aa5174f3799869ade74a51c13e59f4e0d0751226194d8a84ee92)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createQueryDurationWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="connectionAlarmFactory")
    def connection_alarm_factory(self) -> ConnectionAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ConnectionAlarmFactory, jsii.get(self, "connectionAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="connectionAnnotations")
    def connection_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "connectionAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="diskSpaceUsageMetric")
    def disk_space_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "diskSpaceUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="longQueryDurationMetric")
    def long_query_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "longQueryDurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="maintenanceModeMetric")
    def maintenance_mode_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "maintenanceModeMetric"))

    @builtins.property
    @jsii.member(jsii_name="mediumQueryDurationMetric")
    def medium_query_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "mediumQueryDurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="queryDurationAnnotations")
    def query_duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "queryDurationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="readLatencyMetric")
    def read_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="shortQueryDurationMetric")
    def short_query_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "shortQueryDurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> "UsageAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("UsageAlarmFactory", jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="writeLatencyMetric")
    def write_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


@jsii.implements(IMetricAdjuster)
class Route53HealthCheckMetricAdjuster(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.Route53HealthCheckMetricAdjuster",
):
    '''(experimental) Adjusts a metric so that alarms created from it can be used in Route53 Health Checks.

    The metric will be validated to ensure it satisfies Route53 Health Check alarm requirements, otherwise it will throw an {@link Error}.

    :see: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/health-checks-types.html
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="adjustMetric")
    def adjust_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_scope: _constructs_77d1e7e8.Construct,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adjusts a metric.

        :param metric: -
        :param alarm_scope: -
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        :inheritdoc: true
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f65720457606681702580e4a6f60fcbd81bb9e29adbd66849909d7622287cb3)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument alarm_scope", value=alarm_scope, expected_type=type_hints["alarm_scope"])
        props = AddAlarmProps(
            alarm_description=alarm_description,
            alarm_name_suffix=alarm_name_suffix,
            comparison_operator=comparison_operator,
            threshold=threshold,
            treat_missing_data=treat_missing_data,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
        )

        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adjustMetric", [metric, alarm_scope, props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="INSTANCE")
    def INSTANCE(cls) -> "Route53HealthCheckMetricAdjuster":
        '''
        :stability: experimental
        '''
        return typing.cast("Route53HealthCheckMetricAdjuster", jsii.sget(cls, "INSTANCE"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RunningTaskCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_running_tasks": "maxRunningTasks",
    },
)
class RunningTaskCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_running_tasks: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_running_tasks: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cc987685893d9e275ef0330957eb1f56d8338d48c85bbed40c12d369c7a8d25)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_running_tasks", value=max_running_tasks, expected_type=type_hints["max_running_tasks"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_running_tasks": max_running_tasks,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_running_tasks(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_running_tasks")
        assert result is not None, "Required property 'max_running_tasks' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RunningTaskCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RunningTaskRateThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_running_task_rate": "maxRunningTaskRate",
    },
)
class RunningTaskRateThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_running_task_rate: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_running_task_rate: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a4ac8e8c53344ab2dfa21d730313dc804c63e07bfdf1d3b6cebe2ba61ba23987)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_running_task_rate", value=max_running_task_rate, expected_type=type_hints["max_running_task_rate"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_running_task_rate": max_running_task_rate,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_running_task_rate(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_running_task_rate")
        assert result is not None, "Required property 'max_running_task_rate' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RunningTaskRateThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class S3BucketMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.S3BucketMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        storage_type: typing.Optional["StorageType"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param bucket: 
        :param storage_type: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__096cb2fb4e2f6e7dac06f84f2b2f940d3303e46503ef5e95153938944b1467a2)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = S3BucketMetricFactoryProps(
            bucket=bucket, storage_type=storage_type, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricBucketSizeBytes")
    def metric_bucket_size_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricBucketSizeBytes", []))

    @jsii.member(jsii_name="metricNumberOfObjects")
    def metric_number_of_objects(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNumberOfObjects", []))

    @builtins.property
    @jsii.member(jsii_name="props")
    def _props(self) -> "S3BucketMetricFactoryProps":
        '''
        :stability: experimental
        '''
        return typing.cast("S3BucketMetricFactoryProps", jsii.get(self, "props"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.S3BucketMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "bucket": "bucket",
        "storage_type": "storageType",
    },
)
class S3BucketMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        storage_type: typing.Optional["StorageType"] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param bucket: 
        :param storage_type: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e582b02ed9a6ccef5784b86a08b0cbf5506f440cd60f39a4e381934576fa4d27)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if storage_type is not None:
            self._values["storage_type"] = storage_type

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
        '''
        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, result)

    @builtins.property
    def storage_type(self) -> typing.Optional["StorageType"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("storage_type")
        return typing.cast(typing.Optional["StorageType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3BucketMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class S3BucketMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.S3BucketMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        storage_type: typing.Optional["StorageType"] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param bucket: 
        :param storage_type: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3d89b45e13082029f0f87160a569e5b10198f3a435d9b471e123370013adfd3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = S3BucketMonitoringProps(
            bucket=bucket,
            storage_type=storage_type,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="bucketSizeBytesMetric")
    def _bucket_size_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "bucketSizeBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="numberOfObjectsMetric")
    def _number_of_objects_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "numberOfObjectsMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def _title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def _url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


class SecretsManagerAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3bc814298a996859d4783ab8d9fa76f017185a7b799a1965d82c302dee6ad4d0)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addChangeInSecretCountAlarm")
    def add_change_in_secret_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["ChangeInSecretCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b7538cb0f8757fb8399d17c84ebf4d99691cdee82fa77a7bd7c554f818f8753)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addChangeInSecretCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxSecretCountAlarm")
    def add_max_secret_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c92e63e420d6ae22bd2e4749342e8f02da1c41e38aa913269947f2fea2ca2d13)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxSecretCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinSecretCountAlarm")
    def add_min_secret_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bb7052cf9da993a0104898702cc0dc914243f3b9f0dc3b207f9cd7dc2f84412)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinSecretCountAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class SecretsManagerMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__616aa6f623191f3c8aca599c3127dd0449f96d3c05116441e98a0095673d4c51)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = BaseMetricFactoryProps(account=account, region=region)

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricSecretCount")
    def metric_secret_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSecretCount", []))


class SecretsManagerMetricsPublisher(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerMetricsPublisher",
):
    '''
    :stability: experimental
    '''

    @jsii.member(jsii_name="getInstance")
    @builtins.classmethod
    def get_instance(cls, scope: MonitoringScope) -> "SecretsManagerMetricsPublisher":
        '''
        :param scope: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0b4182cc15b560548257bc4a3a38f08ba4c851ee271ac7fcce6124c8bd99174)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("SecretsManagerMetricsPublisher", jsii.sinvoke(cls, "getInstance", [scope]))

    @jsii.member(jsii_name="addSecret")
    def add_secret(self, secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret) -> None:
        '''
        :param secret: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f5f3471cd35949a7eb3e39e43bc7c1258a0495377758359c6c4a19caab6fd6e)
            check_type(argname="argument secret", value=secret, expected_type=type_hints["secret"])
        return typing.cast(None, jsii.invoke(self, "addSecret", [secret]))

    @builtins.property
    @jsii.member(jsii_name="lambda")
    def lambda_(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, jsii.get(self, "lambda"))


class SecretsManagerMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union["ChangeInSecretCountThreshold", typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_change_in_secrets_alarm: 
        :param add_max_number_secrets_alarm: 
        :param add_min_number_secrets_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6627b909164cade742b8cc3c44376243424d9ff4198741d4f0aab62c3070e3c6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SecretsManagerMonitoringProps(
            add_change_in_secrets_alarm=add_change_in_secrets_alarm,
            add_max_number_secrets_alarm=add_max_number_secrets_alarm,
            add_min_number_secrets_alarm=add_min_number_secrets_alarm,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createSecretsCountWidget")
    def create_secrets_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7ed91bf700255a73268dd866b48d73a39d8b317f88c369be4a1715e0bbd518ec)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createSecretsCountWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="secretsCountAnnotation")
    def secrets_count_annotation(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "secretsCountAnnotation"))

    @builtins.property
    @jsii.member(jsii_name="secretsCountMetric")
    def secrets_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "secretsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="secretsManagerAlarmFactory")
    def secrets_manager_alarm_factory(self) -> SecretsManagerAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(SecretsManagerAlarmFactory, jsii.get(self, "secretsManagerAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


class SecretsManagerSecretMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerSecretMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param secret: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e75baabd3f5df4747ee045e1d9d446789fed0b7c51649d1f867f6fdfe6fb1264)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = SecretsManagerSecretMetricFactoryProps(
            secret=secret, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricDaysSinceLastChange")
    def metric_days_since_last_change(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDaysSinceLastChange", []))

    @jsii.member(jsii_name="metricDaysSinceLastRotation")
    def metric_days_since_last_rotation(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDaysSinceLastRotation", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MetricNameDaysSinceLastChange")
    def METRIC_NAME_DAYS_SINCE_LAST_CHANGE(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MetricNameDaysSinceLastChange"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MetricNameDaysSinceLastRotation")
    def METRIC_NAME_DAYS_SINCE_LAST_ROTATION(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "MetricNameDaysSinceLastRotation"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="Namespace")
    def NAMESPACE(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "Namespace"))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="secret")
    def _secret(self) -> _aws_cdk_aws_secretsmanager_ceddda9d.ISecret:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_secretsmanager_ceddda9d.ISecret, jsii.get(self, "secret"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SecretsManagerSecretMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "secret": "secret"},
)
class SecretsManagerSecretMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param secret: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9179934fd0d9fcf372fb3ecb13c5dd468a0f9b89755959cb3dd13e02cb798460)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret", value=secret, expected_type=type_hints["secret"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "secret": secret,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret(self) -> _aws_cdk_aws_secretsmanager_ceddda9d.ISecret:
        '''
        :stability: experimental
        '''
        result = self._values.get("secret")
        assert result is not None, "Required property 'secret' is missing"
        return typing.cast(_aws_cdk_aws_secretsmanager_ceddda9d.ISecret, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecretsManagerSecretMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SecretsManagerSecretMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SecretsManagerSecretMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
        add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        show_last_rotation_widget: typing.Optional[builtins.bool] = None,
        use_publisher: typing.Optional[IPublisherConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param secret: 
        :param add_days_since_last_change_alarm: 
        :param add_days_since_last_rotation_alarm: 
        :param show_last_rotation_widget: Default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.
        :param use_publisher: (experimental) Provides access to the underlying metrics publisher Lambda function. This may be useful if you want to monitor the function itself.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a19be3068017849af5a32a8b10b17cdd71d10300ed227884c66d2eb565e1bc7d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SecretsManagerSecretMonitoringProps(
            secret=secret,
            add_days_since_last_change_alarm=add_days_since_last_change_alarm,
            add_days_since_last_rotation_alarm=add_days_since_last_rotation_alarm,
            show_last_rotation_widget=show_last_rotation_widget,
            use_publisher=use_publisher,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createDaysSinceLastChangeWidget")
    def create_days_since_last_change_widget(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDaysSinceLastChangeWidget", []))

    @jsii.member(jsii_name="createDaysSinceLastRotationWidget")
    def create_days_since_last_rotation_widget(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDaysSinceLastRotationWidget", []))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="daysSinceLastChangeAnnotations")
    def days_since_last_change_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "daysSinceLastChangeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="daysSinceLastChangeMetric")
    def days_since_last_change_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "daysSinceLastChangeMetric"))

    @builtins.property
    @jsii.member(jsii_name="daysSinceLastRotationAnnotations")
    def days_since_last_rotation_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "daysSinceLastRotationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="daysSinceLastRotationMetric")
    def days_since_last_rotation_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "daysSinceLastRotationMetric"))

    @builtins.property
    @jsii.member(jsii_name="showLastRotationWidget")
    def show_last_rotation_widget(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "showLastRotationWidget"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


class SingleAxisGraphWidget(
    _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SingleAxisGraphWidget",
):
    '''(experimental) Line graph widget with one axis only (left).

    If there is just one metric, it will hide the legend to save space.
    The purpose of this custom class is to make the properties more strict.
    It will avoid graphs with undefined axis and dimensions.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        height: jsii.Number,
        left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        width: jsii.Number,
        left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        title: typing.Optional[builtins.str] = None,
        vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param height: 
        :param left_axis: 
        :param left_metrics: 
        :param width: 
        :param left_annotations: 
        :param title: 
        :param vertical_annotations: 

        :stability: experimental
        '''
        props = SingleAxisGraphWidgetProps(
            height=height,
            left_axis=left_axis,
            left_metrics=left_metrics,
            width=width,
            left_annotations=left_annotations,
            title=title,
            vertical_annotations=vertical_annotations,
        )

        jsii.create(self.__class__, self, [props])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SingleAxisGraphWidgetProps",
    jsii_struct_bases=[],
    name_mapping={
        "height": "height",
        "left_axis": "leftAxis",
        "left_metrics": "leftMetrics",
        "width": "width",
        "left_annotations": "leftAnnotations",
        "title": "title",
        "vertical_annotations": "verticalAnnotations",
    },
)
class SingleAxisGraphWidgetProps:
    def __init__(
        self,
        *,
        height: jsii.Number,
        left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
        left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
        width: jsii.Number,
        left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
        title: typing.Optional[builtins.str] = None,
        vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param height: 
        :param left_axis: 
        :param left_metrics: 
        :param width: 
        :param left_annotations: 
        :param title: 
        :param vertical_annotations: 

        :stability: experimental
        '''
        if isinstance(left_axis, dict):
            left_axis = _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps(**left_axis)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d72bf22c52f04fd226d58000182c7e1cc0ffaace8ad51a30f291b9867034aa68)
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
            check_type(argname="argument left_axis", value=left_axis, expected_type=type_hints["left_axis"])
            check_type(argname="argument left_metrics", value=left_metrics, expected_type=type_hints["left_metrics"])
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument left_annotations", value=left_annotations, expected_type=type_hints["left_annotations"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
            check_type(argname="argument vertical_annotations", value=vertical_annotations, expected_type=type_hints["vertical_annotations"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "height": height,
            "left_axis": left_axis,
            "left_metrics": left_metrics,
            "width": width,
        }
        if left_annotations is not None:
            self._values["left_annotations"] = left_annotations
        if title is not None:
            self._values["title"] = title
        if vertical_annotations is not None:
            self._values["vertical_annotations"] = vertical_annotations

    @builtins.property
    def height(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("height")
        assert result is not None, "Required property 'height' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def left_axis(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_axis")
        assert result is not None, "Required property 'left_axis' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, result)

    @builtins.property
    def left_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_metrics")
        assert result is not None, "Required property 'left_metrics' is missing"
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], result)

    @builtins.property
    def width(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("width")
        assert result is not None, "Required property 'width' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def left_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("left_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vertical_annotations(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("vertical_annotations")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SingleAxisGraphWidgetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IDashboardSegment, IDynamicDashboardSegment)
class SingleWidgetDashboardSegment(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SingleWidgetDashboardSegment",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
        dashboards_to_include: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''(experimental) Create a dashboard segment representing a single widget.

        :param widget: widget to add.
        :param dashboards_to_include: list of dashboard names which to show this widget on. Defaults to the default dashboards.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8e0eb186116c26e720fe3990d6b02393d658c0ebb7b269c251f984e195974e7c)
            check_type(argname="argument widget", value=widget, expected_type=type_hints["widget"])
            check_type(argname="argument dashboards_to_include", value=dashboards_to_include, expected_type=type_hints["dashboards_to_include"])
        jsii.create(self.__class__, self, [widget, dashboards_to_include])

    @jsii.member(jsii_name="alarmWidgets")
    def alarm_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for all alarms.

        These should go to the runbook or service dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "alarmWidgets", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the summary.

        These should go to the team OPS dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns all widgets.

        These should go to the detailed service dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @jsii.member(jsii_name="widgetsForDashboard")
    def widgets_for_dashboard(
        self,
        name: builtins.str,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets for the requested dashboard type.

        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a5c89d9eb9012fc2240c58612071e610bec40747ed027ec64c296ce8a6ef7341)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgetsForDashboard", [name]))

    @builtins.property
    @jsii.member(jsii_name="dashboardsToInclude")
    def _dashboards_to_include(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "dashboardsToInclude"))

    @builtins.property
    @jsii.member(jsii_name="widget")
    def _widget(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.IWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IWidget, jsii.get(self, "widget"))


@jsii.implements(IAlarmActionStrategy)
class SnsAlarmActionStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SnsAlarmActionStrategy",
):
    '''(experimental) Alarm action strategy that sends a notification to the specified SNS topic.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        on_alarm_topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        on_insufficient_data_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        on_ok_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    ) -> None:
        '''
        :param on_alarm_topic: (experimental) Target topic used when the alarm is triggered.
        :param on_insufficient_data_topic: (experimental) Optional target topic for when the alarm goes into the INSUFFICIENT_DATA state. Default: - no notification sent
        :param on_ok_topic: (experimental) Optional target topic for when the alarm goes into the OK state. Default: - no notification sent

        :stability: experimental
        '''
        props = SnsAlarmActionStrategyProps(
            on_alarm_topic=on_alarm_topic,
            on_insufficient_data_topic=on_insufficient_data_topic,
            on_ok_topic=on_ok_topic,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="addAlarmActions")
    def add_alarm_actions(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmActionStrategyProps(
            alarm=alarm,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(None, jsii.invoke(self, "addAlarmActions", [props]))

    @builtins.property
    @jsii.member(jsii_name="onAlarmTopic")
    def _on_alarm_topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, jsii.get(self, "onAlarmTopic"))

    @builtins.property
    @jsii.member(jsii_name="onInsufficientDataTopic")
    def _on_insufficient_data_topic(
        self,
    ) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], jsii.get(self, "onInsufficientDataTopic"))

    @builtins.property
    @jsii.member(jsii_name="onOkTopic")
    def _on_ok_topic(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], jsii.get(self, "onOkTopic"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SnsAlarmActionStrategyProps",
    jsii_struct_bases=[],
    name_mapping={
        "on_alarm_topic": "onAlarmTopic",
        "on_insufficient_data_topic": "onInsufficientDataTopic",
        "on_ok_topic": "onOkTopic",
    },
)
class SnsAlarmActionStrategyProps:
    def __init__(
        self,
        *,
        on_alarm_topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        on_insufficient_data_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        on_ok_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    ) -> None:
        '''
        :param on_alarm_topic: (experimental) Target topic used when the alarm is triggered.
        :param on_insufficient_data_topic: (experimental) Optional target topic for when the alarm goes into the INSUFFICIENT_DATA state. Default: - no notification sent
        :param on_ok_topic: (experimental) Optional target topic for when the alarm goes into the OK state. Default: - no notification sent

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8f1f03ee91dbc151a3ddfd104145330525b1bf4c76e01c5ee96c6dc977340ca7)
            check_type(argname="argument on_alarm_topic", value=on_alarm_topic, expected_type=type_hints["on_alarm_topic"])
            check_type(argname="argument on_insufficient_data_topic", value=on_insufficient_data_topic, expected_type=type_hints["on_insufficient_data_topic"])
            check_type(argname="argument on_ok_topic", value=on_ok_topic, expected_type=type_hints["on_ok_topic"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "on_alarm_topic": on_alarm_topic,
        }
        if on_insufficient_data_topic is not None:
            self._values["on_insufficient_data_topic"] = on_insufficient_data_topic
        if on_ok_topic is not None:
            self._values["on_ok_topic"] = on_ok_topic

    @builtins.property
    def on_alarm_topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        '''(experimental) Target topic used when the alarm is triggered.

        :stability: experimental
        '''
        result = self._values.get("on_alarm_topic")
        assert result is not None, "Required property 'on_alarm_topic' is missing"
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, result)

    @builtins.property
    def on_insufficient_data_topic(
        self,
    ) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''(experimental) Optional target topic for when the alarm goes into the INSUFFICIENT_DATA state.

        :default: - no notification sent

        :stability: experimental
        '''
        result = self._values.get("on_insufficient_data_topic")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], result)

    @builtins.property
    def on_ok_topic(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''(experimental) Optional target topic for when the alarm goes into the OK state.

        :default: - no notification sent

        :stability: experimental
        '''
        result = self._values.get("on_ok_topic")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SnsAlarmActionStrategyProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SnsTopicMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SnsTopicMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param topic: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f08a0a9ffa034de35220c631b72c223320fb3c080acb01aba1d39dc24d7b88d8)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = SnsTopicMetricFactoryProps(topic=topic, account=account, region=region)

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAverageMessageSizeInBytes")
    def metric_average_message_size_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageMessageSizeInBytes", []))

    @jsii.member(jsii_name="metricIncomingMessageCount")
    def metric_incoming_message_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingMessageCount", []))

    @jsii.member(jsii_name="metricNumberOfNotificationsFailed")
    def metric_number_of_notifications_failed(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNumberOfNotificationsFailed", []))

    @jsii.member(jsii_name="metricOutgoingMessageCount")
    def metric_outgoing_message_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricOutgoingMessageCount", []))

    @builtins.property
    @jsii.member(jsii_name="topic")
    def _topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, jsii.get(self, "topic"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SnsTopicMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "topic": "topic"},
)
class SnsTopicMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param topic: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08afa0fabdd34684d04c57f06039a22782ecb203fcb149e4ed216df1bf1708d8)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "topic": topic,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        '''
        :stability: experimental
        '''
        result = self._values.get("topic")
        assert result is not None, "Required property 'topic' is missing"
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SnsTopicMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SnsTopicMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SnsTopicMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param topic: 
        :param add_max_number_of_messages_published_alarm: 
        :param add_message_notifications_failed_alarm: 
        :param add_min_number_of_messages_published_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9cb096ad11a88f652e67ffd68df01d2b133aafd9ae3abc4f794ee93b644d75d5)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SnsTopicMonitoringProps(
            topic=topic,
            add_max_number_of_messages_published_alarm=add_max_number_of_messages_published_alarm,
            add_message_notifications_failed_alarm=add_message_notifications_failed_alarm,
            add_min_number_of_messages_published_alarm=add_min_number_of_messages_published_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createMessageCountWidget")
    def create_message_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f65032f905eb5f3b762a60bd3d13acf1ef2c3433a0f25aeb5b403d81bceda38)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageCountWidget", [width, height]))

    @jsii.member(jsii_name="createMessageFailedWidget")
    def create_message_failed_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2a3bf0754fecf9935ad74ac425f0abc7a072edc195f2c351b0a5d3f03f4dc25)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageFailedWidget", [width, height]))

    @jsii.member(jsii_name="createMessageSizeWidget")
    def create_message_size_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3696704314d733e185331a410e0a61b064ecfe00cf672d49f4a9973061f2d7d7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageSizeWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="failedDeliveryAnnotations")
    def failed_delivery_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "failedDeliveryAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="incomingMessagesAnnotations")
    def incoming_messages_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "incomingMessagesAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="incomingMessagesMetric")
    def incoming_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="messagesFailedMetric")
    def messages_failed_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "messagesFailedMetric"))

    @builtins.property
    @jsii.member(jsii_name="messageSizeMetric")
    def message_size_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "messageSizeMetric"))

    @builtins.property
    @jsii.member(jsii_name="outgoingMessagesMetric")
    def outgoing_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "outgoingMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="topicAlarmFactory")
    def topic_alarm_factory(self) -> "TopicAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("TopicAlarmFactory", jsii.get(self, "topicAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="topicUrl")
    def topic_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "topicUrl"))


class SqsQueueMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SqsQueueMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param queue: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d6281f46ce13fc94b35446126deeaba6953f71d44f38b85e54818a62eea29b21)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = SqsQueueMetricFactoryProps(queue=queue, account=account, region=region)

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricApproximateAgeOfOldestMessageInSeconds")
    def metric_approximate_age_of_oldest_message_in_seconds(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricApproximateAgeOfOldestMessageInSeconds", []))

    @jsii.member(jsii_name="metricApproximateVisibleMessageCount")
    def metric_approximate_visible_message_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricApproximateVisibleMessageCount", []))

    @jsii.member(jsii_name="metricAverageMessageSizeInBytes")
    def metric_average_message_size_in_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAverageMessageSizeInBytes", []))

    @jsii.member(jsii_name="metricConsumptionRate")
    def metric_consumption_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricConsumptionRate", []))

    @jsii.member(jsii_name="metricDeletedMessageCount")
    def metric_deleted_message_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricDeletedMessageCount", []))

    @jsii.member(jsii_name="metricIncomingMessageCount")
    def metric_incoming_message_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIncomingMessageCount", []))

    @jsii.member(jsii_name="metricProductionRate")
    def metric_production_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProductionRate", []))

    @jsii.member(jsii_name="metricTimeToDrain")
    def metric_time_to_drain(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTimeToDrain", []))

    @builtins.property
    @jsii.member(jsii_name="queue")
    def _queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, jsii.get(self, "queue"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SqsQueueMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "queue": "queue"},
)
class SqsQueueMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param queue: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d216c2df4b399ede82a7d8409225a5fe851553340d92ccb2b3918fc83687a2c3)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument queue", value=queue, expected_type=type_hints["queue"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "queue": queue,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        '''
        :stability: experimental
        '''
        result = self._values.get("queue")
        assert result is not None, "Required property 'queue' is missing"
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SqsQueueMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SqsQueueMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SqsQueueMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        props: typing.Union["SqsQueueMonitoringProps", typing.Dict[builtins.str, typing.Any]],
        invoked_from_super: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param props: -
        :param invoked_from_super: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58c846089f933e52c75be62f3c8bbcb4f22fa03c3c4237313f94fd7be3c4faa7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument invoked_from_super", value=invoked_from_super, expected_type=type_hints["invoked_from_super"])
        jsii.create(self.__class__, self, [scope, props, invoked_from_super])

    @jsii.member(jsii_name="createMessageAgeWidget")
    def create_message_age_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a5fc521ee6edc97cd2d956c5fadcfe72a420626fa7142ed063233a52ceaf619)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageAgeWidget", [width, height]))

    @jsii.member(jsii_name="createMessageCountWidget")
    def create_message_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3030932814989949b83801008bfb8758901515fa3703bf279856c55d131de38e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageCountWidget", [width, height]))

    @jsii.member(jsii_name="createMessageSizeWidget")
    def create_message_size_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61893c096f81543db130a3057878222795671e8920594175dfffa8a794b9697e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMessageSizeWidget", [width, height]))

    @jsii.member(jsii_name="createProducerAndConsumerRateWidget")
    def create_producer_and_consumer_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2d37f896e6a3fd47f74c396b511fd67ed8beba7f012692294f4c77ead6ce4e9)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createProducerAndConsumerRateWidget", [width, height]))

    @jsii.member(jsii_name="createTimeToDrainWidget")
    def create_time_to_drain_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__067bcaeca31d0d01f00867ceeedc3a86d737e904790b316fe4c68e03c41fda62)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTimeToDrainWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="resolveQueueName")
    def _resolve_queue_name(
        self,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    ) -> typing.Optional[builtins.str]:
        '''
        :param queue: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5010cb483880c36ba0eeb0cda51e487a14bef7793bec189c748f4756d331ac2f)
            check_type(argname="argument queue", value=queue, expected_type=type_hints["queue"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "resolveQueueName", [queue]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="ageAnnotations")
    def age_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "ageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="consumptionRateMetric")
    def consumption_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "consumptionRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="countAnnotations")
    def count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "countAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="deletedMessagesMetric")
    def deleted_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deletedMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="incomingMessagesMetric")
    def incoming_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="messageSizeMetric")
    def message_size_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "messageSizeMetric"))

    @builtins.property
    @jsii.member(jsii_name="oldestMessageAgeMetric")
    def oldest_message_age_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "oldestMessageAgeMetric"))

    @builtins.property
    @jsii.member(jsii_name="productionRateMetric")
    def production_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "productionRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="queueAlarmFactory")
    def queue_alarm_factory(self) -> QueueAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(QueueAlarmFactory, jsii.get(self, "queueAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="timeToDrainAnnotations")
    def time_to_drain_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "timeToDrainAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="timeToDrainMetric")
    def time_to_drain_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timeToDrainMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="visibleMessagesMetric")
    def visible_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "visibleMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="queueUrl")
    def queue_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "queueUrl"))


class SqsQueueMonitoringWithDlq(
    SqsQueueMonitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SqsQueueMonitoringWithDlq",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        dead_letter_queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        add_dead_letter_queue_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param dead_letter_queue: 
        :param add_dead_letter_queue_to_summary_dashboard: (experimental) Indicates whether the DLQ monitoring should be added to summary dashboard. Default: - true
        :param add_dead_letter_queue_max_incoming_messages_alarm: (experimental) Alarm on the number of messages added to a queue. Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ as a result of a failed processing attempt.
        :param add_dead_letter_queue_max_message_age_alarm: 
        :param add_dead_letter_queue_max_size_alarm: 
        :param queue: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4766b7345cc8076998016b3b5087b826d6622a573592646eb4b25602c81d13e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SqsQueueMonitoringWithDlqProps(
            dead_letter_queue=dead_letter_queue,
            add_dead_letter_queue_to_summary_dashboard=add_dead_letter_queue_to_summary_dashboard,
            add_dead_letter_queue_max_incoming_messages_alarm=add_dead_letter_queue_max_incoming_messages_alarm,
            add_dead_letter_queue_max_message_age_alarm=add_dead_letter_queue_max_message_age_alarm,
            add_dead_letter_queue_max_size_alarm=add_dead_letter_queue_max_size_alarm,
            queue=queue,
            account=account,
            region=region,
            add_queue_max_incoming_messages_alarm=add_queue_max_incoming_messages_alarm,
            add_queue_max_message_age_alarm=add_queue_max_message_age_alarm,
            add_queue_max_size_alarm=add_queue_max_size_alarm,
            add_queue_max_time_to_drain_messages_alarm=add_queue_max_time_to_drain_messages_alarm,
            add_queue_min_incoming_messages_alarm=add_queue_min_incoming_messages_alarm,
            add_queue_min_size_alarm=add_queue_min_size_alarm,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createDeadLetterMessageAgeWidget")
    def _create_dead_letter_message_age_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9aa7db1138892fed7d47e6e20c69b9c0c7a523850f36e1b88700b1233eb3ca90)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDeadLetterMessageAgeWidget", [width, height]))

    @jsii.member(jsii_name="createDeadLetterMessageCountWidget")
    def _create_dead_letter_message_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__011bc897e9dd91c2937b726e63a3c133d976755c0d93b329c63dd9c31633be67)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDeadLetterMessageCountWidget", [width, height]))

    @jsii.member(jsii_name="createDeadLetterTitleWidget")
    def _create_dead_letter_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createDeadLetterTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="addDeadLetterQueueToSummaryDashboard")
    def _add_dead_letter_queue_to_summary_dashboard(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "addDeadLetterQueueToSummaryDashboard"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterAgeAnnotations")
    def _dead_letter_age_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "deadLetterAgeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterCountAnnotations")
    def _dead_letter_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "deadLetterCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterQueueAlarmFactory")
    def _dead_letter_queue_alarm_factory(self) -> QueueAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(QueueAlarmFactory, jsii.get(self, "deadLetterQueueAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterQueueIncomingMessagesMetric")
    def _dead_letter_queue_incoming_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deadLetterQueueIncomingMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterQueueOldestMessageAgeMetric")
    def _dead_letter_queue_oldest_message_age_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deadLetterQueueOldestMessageAgeMetric"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterQueueVisibleMessagesMetric")
    def _dead_letter_queue_visible_messages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deadLetterQueueVisibleMessagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterTitle")
    def _dead_letter_title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "deadLetterTitle"))

    @builtins.property
    @jsii.member(jsii_name="deadLetterUrl")
    def _dead_letter_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deadLetterUrl"))


@jsii.implements(IDynamicDashboardSegment)
class StaticSegmentDynamicAdapter(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StaticSegmentDynamicAdapter",
):
    '''
    :stability: experimental
    '''

    def __init__(self, props: IDashboardFactoryProps) -> None:
        '''
        :param props: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__66bc9c402ad7ecda78356299ba29f715ae0ffd9e3f259f3d77dff9b1da309eed)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="widgetsForDashboard")
    def widgets_for_dashboard(
        self,
        name: builtins.str,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Adapts an IDashboardSegment to the IDynamicDashboardSegment interface by using overrideProps to determine if a segment should be shown on a specific dashboard.

        The default values are true, so consumers must set these to false if they would
        like to hide these items from dashboards

        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d52640dc60ef9455eaee64501cab4364f0346f2966724c047e53bcd77e3d35a)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgetsForDashboard", [name]))

    @builtins.property
    @jsii.member(jsii_name="props")
    def _props(self) -> IDashboardFactoryProps:
        '''
        :stability: experimental
        '''
        return typing.cast(IDashboardFactoryProps, jsii.get(self, "props"))


class StepFunctionActivityMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionActivityMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param activity: 
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49edc223731d32ecc673008aab76a1b75fe71db9b0779ed8aee2aa94789f4b2d)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = StepFunctionActivityMetricFactoryProps(
            activity=activity,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricActivitiesFailed")
    def metric_activities_failed(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesFailed", []))

    @jsii.member(jsii_name="metricActivitiesFailedRate")
    def metric_activities_failed_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesFailedRate", []))

    @jsii.member(jsii_name="metricActivitiesHeartbeatTimedOut")
    def metric_activities_heartbeat_timed_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesHeartbeatTimedOut", []))

    @jsii.member(jsii_name="metricActivitiesScheduled")
    def metric_activities_scheduled(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesScheduled", []))

    @jsii.member(jsii_name="metricActivitiesStarted")
    def metric_activities_started(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesStarted", []))

    @jsii.member(jsii_name="metricActivitiesSucceeded")
    def metric_activities_succeeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesSucceeded", []))

    @jsii.member(jsii_name="metricActivitiesTimedOut")
    def metric_activities_timed_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivitiesTimedOut", []))

    @jsii.member(jsii_name="metricActivityRunTimeP50InMillis")
    def metric_activity_run_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityRunTimeP50InMillis", []))

    @jsii.member(jsii_name="metricActivityRunTimeP90InMillis")
    def metric_activity_run_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityRunTimeP90InMillis", []))

    @jsii.member(jsii_name="metricActivityRunTimeP99InMillis")
    def metric_activity_run_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityRunTimeP99InMillis", []))

    @jsii.member(jsii_name="metricActivityScheduleTimeP50InMillis")
    def metric_activity_schedule_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityScheduleTimeP50InMillis", []))

    @jsii.member(jsii_name="metricActivityScheduleTimeP90InMillis")
    def metric_activity_schedule_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityScheduleTimeP90InMillis", []))

    @jsii.member(jsii_name="metricActivityScheduleTimeP99InMillis")
    def metric_activity_schedule_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityScheduleTimeP99InMillis", []))

    @jsii.member(jsii_name="metricActivityTimeP50InMillis")
    def metric_activity_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityTimeP50InMillis", []))

    @jsii.member(jsii_name="metricActivityTimeP90InMillis")
    def metric_activity_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityTimeP90InMillis", []))

    @jsii.member(jsii_name="metricActivityTimeP99InMillis")
    def metric_activity_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActivityTimeP99InMillis", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionActivityMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "activity": "activity",
        "rate_computation_method": "rateComputationMethod",
    },
)
class StepFunctionActivityMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param activity: 
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3e4262e5aa7a43e4394ac3a1a696f71c6014b33f65d4428b66a51f7d81994bd9)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument activity", value=activity, expected_type=type_hints["activity"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "activity": activity,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def activity(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.IActivity:
        '''
        :stability: experimental
        '''
        result = self._values.get("activity")
        assert result is not None, "Required property 'activity' is missing"
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.IActivity, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionActivityMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class StepFunctionActivityMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionActivityMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_activities_count_alarm: 
        :param add_failed_activities_rate_alarm: 
        :param add_timed_out_activities_count_alarm: 
        :param activity: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22e3bf314eb4d982c463d555b038f5e4b71f5e5f37b9ff377f59e15532cce08f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = StepFunctionActivityMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_activities_count_alarm=add_failed_activities_count_alarm,
            add_failed_activities_rate_alarm=add_failed_activities_rate_alarm,
            add_timed_out_activities_count_alarm=add_timed_out_activities_count_alarm,
            activity=activity,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="durationAlarmFactory")
    def duration_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "durationAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="durationAnnotations")
    def duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "durationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedActivitiesMetric")
    def failed_activities_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedActivitiesMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedActivitiesRateMetric")
    def failed_activities_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedActivitiesRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="heartbeatTimedOutActivitiesMetrics")
    def heartbeat_timed_out_activities_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "heartbeatTimedOutActivitiesMetrics"))

    @builtins.property
    @jsii.member(jsii_name="p50DurationMetric")
    def p50_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90DurationMetric")
    def p90_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99DurationMetric")
    def p99_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="scheduledActivitiesMetric")
    def scheduled_activities_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "scheduledActivitiesMetric"))

    @builtins.property
    @jsii.member(jsii_name="startedActivitiesMetric")
    def started_activities_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "startedActivitiesMetric"))

    @builtins.property
    @jsii.member(jsii_name="succeededActivitiesMetric")
    def succeeded_activities_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "succeededActivitiesMetric"))

    @builtins.property
    @jsii.member(jsii_name="timedOutActivitiesMetrics")
    def timed_out_activities_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timedOutActivitiesMetrics"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


class StepFunctionLambdaIntegrationMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionLambdaIntegrationMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param lambda_function: 
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12c9cbd58de35f7d231f6e667cb541abfc04fd9118829d3de8094f16eda9715e)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = StepFunctionLambdaIntegrationMetricFactoryProps(
            lambda_function=lambda_function,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricFunctionRunTimeP50InMillis")
    def metric_function_run_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionRunTimeP50InMillis", []))

    @jsii.member(jsii_name="metricFunctionRunTimeP90InMillis")
    def metric_function_run_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionRunTimeP90InMillis", []))

    @jsii.member(jsii_name="metricFunctionRunTimeP99InMillis")
    def metric_function_run_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionRunTimeP99InMillis", []))

    @jsii.member(jsii_name="metricFunctionScheduleTimeP50InMillis")
    def metric_function_schedule_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionScheduleTimeP50InMillis", []))

    @jsii.member(jsii_name="metricFunctionScheduleTimeP90InMillis")
    def metric_function_schedule_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionScheduleTimeP90InMillis", []))

    @jsii.member(jsii_name="metricFunctionScheduleTimeP99InMillis")
    def metric_function_schedule_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionScheduleTimeP99InMillis", []))

    @jsii.member(jsii_name="metricFunctionsFailed")
    def metric_functions_failed(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsFailed", []))

    @jsii.member(jsii_name="metricFunctionsFailedRate")
    def metric_functions_failed_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsFailedRate", []))

    @jsii.member(jsii_name="metricFunctionsScheduled")
    def metric_functions_scheduled(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsScheduled", []))

    @jsii.member(jsii_name="metricFunctionsStarted")
    def metric_functions_started(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsStarted", []))

    @jsii.member(jsii_name="metricFunctionsSucceeded")
    def metric_functions_succeeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsSucceeded", []))

    @jsii.member(jsii_name="metricFunctionsTimedOut")
    def metric_functions_timed_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionsTimedOut", []))

    @jsii.member(jsii_name="metricFunctionTimeP50InMillis")
    def metric_function_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionTimeP50InMillis", []))

    @jsii.member(jsii_name="metricFunctionTimeP90InMillis")
    def metric_function_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionTimeP90InMillis", []))

    @jsii.member(jsii_name="metricFunctionTimeP99InMillis")
    def metric_function_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricFunctionTimeP99InMillis", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionLambdaIntegrationMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "lambda_function": "lambdaFunction",
        "rate_computation_method": "rateComputationMethod",
    },
)
class StepFunctionLambdaIntegrationMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param lambda_function: 
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45d5ea61a173a96c99137e9a83f5e16951f61d4ff3f187f441c7beb88d26fd25)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "lambda_function": lambda_function,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_function")
        assert result is not None, "Required property 'lambda_function' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionLambdaIntegrationMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class StepFunctionLambdaIntegrationMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionLambdaIntegrationMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_functions_count_alarm: 
        :param add_failed_functions_rate_alarm: 
        :param add_timed_out_functions_count_alarm: 
        :param lambda_function: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9980c7315140c32287dc9bd4eafb9faad958c911ac8a6d5b6529ebe4f3a478d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = StepFunctionLambdaIntegrationMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_functions_count_alarm=add_failed_functions_count_alarm,
            add_failed_functions_rate_alarm=add_failed_functions_rate_alarm,
            add_timed_out_functions_count_alarm=add_timed_out_functions_count_alarm,
            lambda_function=lambda_function,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="durationAlarmFactory")
    def duration_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "durationAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="durationAnnotations")
    def duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "durationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedFunctionRateMetric")
    def failed_function_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedFunctionRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedFunctionsMetric")
    def failed_functions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedFunctionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="p50DurationMetric")
    def p50_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90DurationMetric")
    def p90_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99DurationMetric")
    def p99_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="scheduledFunctionsMetric")
    def scheduled_functions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "scheduledFunctionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="startedFunctionsMetric")
    def started_functions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "startedFunctionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="succeededFunctionsMetric")
    def succeeded_functions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "succeededFunctionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="timedOutFunctionsMetrics")
    def timed_out_functions_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timedOutFunctionsMetrics"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="functionUrl")
    def function_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "functionUrl"))


class StepFunctionMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param state_machine: 
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__95ee9fc0578bba779f0e18b19ba8a8a604beb5152b8d68e44b5eba0885858357)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = StepFunctionMetricFactoryProps(
            state_machine=state_machine,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricExecutionsAborted")
    def metric_executions_aborted(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsAborted", []))

    @jsii.member(jsii_name="metricExecutionsFailed")
    def metric_executions_failed(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsFailed", []))

    @jsii.member(jsii_name="metricExecutionsFailedRate")
    def metric_executions_failed_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsFailedRate", []))

    @jsii.member(jsii_name="metricExecutionsStarted")
    def metric_executions_started(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsStarted", []))

    @jsii.member(jsii_name="metricExecutionsSucceeded")
    def metric_executions_succeeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsSucceeded", []))

    @jsii.member(jsii_name="metricExecutionsTimedOut")
    def metric_executions_timed_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionsTimedOut", []))

    @jsii.member(jsii_name="metricExecutionThrottled")
    def metric_execution_throttled(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionThrottled", []))

    @jsii.member(jsii_name="metricExecutionTimeP50InMillis")
    def metric_execution_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionTimeP50InMillis", []))

    @jsii.member(jsii_name="metricExecutionTimeP90InMillis")
    def metric_execution_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionTimeP90InMillis", []))

    @jsii.member(jsii_name="metricExecutionTimeP99InMillis")
    def metric_execution_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricExecutionTimeP99InMillis", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "state_machine": "stateMachine",
        "rate_computation_method": "rateComputationMethod",
    },
)
class StepFunctionMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param state_machine: 
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2124dbb548f355f7952cb56fe99dac2cae37343114bc8851178d0cd982d61d21)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "state_machine": state_machine,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine:
        '''
        :stability: experimental
        '''
        result = self._values.get("state_machine")
        assert result is not None, "Required property 'state_machine' is missing"
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class StepFunctionMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param state_machine: 
        :param rate_computation_method: Default: - average
        :param add_aborted_execution_count_alarm: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_execution_count_alarm: 
        :param add_failed_execution_rate_alarm: 
        :param add_min_started_execution_count_alarm: (experimental) Add minimum started execution count alarm for the stepfunctions.
        :param add_throttled_execution_count_alarm: 
        :param add_timed_out_execution_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1f444743ec032fdacb32bfb44fc74b3059c1ba22ee1cbce13b270a53d973ebe)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = StepFunctionMonitoringProps(
            state_machine=state_machine,
            rate_computation_method=rate_computation_method,
            add_aborted_execution_count_alarm=add_aborted_execution_count_alarm,
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_execution_count_alarm=add_failed_execution_count_alarm,
            add_failed_execution_rate_alarm=add_failed_execution_rate_alarm,
            add_min_started_execution_count_alarm=add_min_started_execution_count_alarm,
            add_throttled_execution_count_alarm=add_throttled_execution_count_alarm,
            add_timed_out_execution_count_alarm=add_timed_out_execution_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="abortedExecutionsMetric")
    def aborted_executions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "abortedExecutionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="durationAlarmFactory")
    def duration_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "durationAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="durationAnnotations")
    def duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "durationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedExecutionRateMetric")
    def failed_execution_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedExecutionRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedExecutionsMetric")
    def failed_executions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedExecutionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="p50DurationMetric")
    def p50_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90DurationMetric")
    def p90_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99DurationMetric")
    def p99_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="startedExecutionsMetric")
    def started_executions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "startedExecutionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="succeededExecutionsMetric")
    def succeeded_executions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "succeededExecutionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAlarmFactory")
    def task_health_alarm_factory(self) -> "TaskHealthAlarmFactory":
        '''
        :stability: experimental
        '''
        return typing.cast("TaskHealthAlarmFactory", jsii.get(self, "taskHealthAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="throttledExecutionsMetric")
    def throttled_executions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "throttledExecutionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="timedOutExecutionsMetrics")
    def timed_out_executions_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timedOutExecutionsMetrics"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="stateMachineUrl")
    def state_machine_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "stateMachineUrl"))


class StepFunctionServiceIntegrationMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionServiceIntegrationMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        service_integration_resource_arn: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param service_integration_resource_arn: 
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8cf99ac9c0bd4222fd3fd4a789569fb102166bde7437894b6a2767865c00acf7)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = StepFunctionServiceIntegrationMetricFactoryProps(
            service_integration_resource_arn=service_integration_resource_arn,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricServiceIntegrationRunTimeP50InMillis")
    def metric_service_integration_run_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationRunTimeP50InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationRunTimeP90InMillis")
    def metric_service_integration_run_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationRunTimeP90InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationRunTimeP99InMillis")
    def metric_service_integration_run_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationRunTimeP99InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationScheduleTimeP50InMillis")
    def metric_service_integration_schedule_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationScheduleTimeP50InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationScheduleTimeP90InMillis")
    def metric_service_integration_schedule_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationScheduleTimeP90InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationScheduleTimeP99InMillis")
    def metric_service_integration_schedule_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationScheduleTimeP99InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationsFailed")
    def metric_service_integrations_failed(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsFailed", []))

    @jsii.member(jsii_name="metricServiceIntegrationsFailedRate")
    def metric_service_integrations_failed_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsFailedRate", []))

    @jsii.member(jsii_name="metricServiceIntegrationsScheduled")
    def metric_service_integrations_scheduled(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsScheduled", []))

    @jsii.member(jsii_name="metricServiceIntegrationsStarted")
    def metric_service_integrations_started(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsStarted", []))

    @jsii.member(jsii_name="metricServiceIntegrationsSucceeded")
    def metric_service_integrations_succeeded(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsSucceeded", []))

    @jsii.member(jsii_name="metricServiceIntegrationsTimedOut")
    def metric_service_integrations_timed_out(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationsTimedOut", []))

    @jsii.member(jsii_name="metricServiceIntegrationTimeP50InMillis")
    def metric_service_integration_time_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationTimeP50InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationTimeP90InMillis")
    def metric_service_integration_time_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationTimeP90InMillis", []))

    @jsii.member(jsii_name="metricServiceIntegrationTimeP99InMillis")
    def metric_service_integration_time_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricServiceIntegrationTimeP99InMillis", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionServiceIntegrationMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "service_integration_resource_arn": "serviceIntegrationResourceArn",
        "rate_computation_method": "rateComputationMethod",
    },
)
class StepFunctionServiceIntegrationMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        service_integration_resource_arn: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param service_integration_resource_arn: 
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67a3dd5e4afad287ab31ecd31da343f5dcc0fd70c6352f99ab9afd000113fbdd)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument service_integration_resource_arn", value=service_integration_resource_arn, expected_type=type_hints["service_integration_resource_arn"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service_integration_resource_arn": service_integration_resource_arn,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_integration_resource_arn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("service_integration_resource_arn")
        assert result is not None, "Required property 'service_integration_resource_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionServiceIntegrationMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class StepFunctionServiceIntegrationMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.StepFunctionServiceIntegrationMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        service_integration_resource_arn: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_service_integrations_count_alarm: 
        :param add_failed_service_integrations_rate_alarm: 
        :param add_timed_out_service_integrations_count_alarm: 
        :param service_integration_resource_arn: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e6a26a70865e4887eeb737095558ac8d8c769d2fbe156f9e37948e857f208f3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = StepFunctionServiceIntegrationMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_service_integrations_count_alarm=add_failed_service_integrations_count_alarm,
            add_failed_service_integrations_rate_alarm=add_failed_service_integrations_rate_alarm,
            add_timed_out_service_integrations_count_alarm=add_timed_out_service_integrations_count_alarm,
            service_integration_resource_arn=service_integration_resource_arn,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="durationAlarmFactory")
    def duration_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "durationAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="durationAnnotations")
    def duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "durationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedServiceIntegrationRateMetric")
    def failed_service_integration_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedServiceIntegrationRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedServiceIntegrationsMetric")
    def failed_service_integrations_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedServiceIntegrationsMetric"))

    @builtins.property
    @jsii.member(jsii_name="p50DurationMetric")
    def p50_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90DurationMetric")
    def p90_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99DurationMetric")
    def p99_duration_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99DurationMetric"))

    @builtins.property
    @jsii.member(jsii_name="scheduledServiceIntegrationsMetric")
    def scheduled_service_integrations_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "scheduledServiceIntegrationsMetric"))

    @builtins.property
    @jsii.member(jsii_name="startedServiceIntegrationsMetric")
    def started_service_integrations_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "startedServiceIntegrationsMetric"))

    @builtins.property
    @jsii.member(jsii_name="succeededServiceIntegrationsMetric")
    def succeeded_service_integrations_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "succeededServiceIntegrationsMetric"))

    @builtins.property
    @jsii.member(jsii_name="timedOutServiceIntegrationsMetrics")
    def timed_out_service_integrations_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timedOutServiceIntegrationsMetrics"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


@jsii.enum(jsii_type="cdk-monitoring-constructs.StorageType")
class StorageType(enum.Enum):
    '''
    :stability: experimental
    '''

    DEEP_ARCHIVE_OBJECT_OVERHEAD = "DEEP_ARCHIVE_OBJECT_OVERHEAD"
    '''
    :stability: experimental
    '''
    DEEP_ARCHIVE_S3_OBJECT_OVERHEAD = "DEEP_ARCHIVE_S3_OBJECT_OVERHEAD"
    '''
    :stability: experimental
    '''
    DEEP_ARCHIVE_STAGING_STORAGE = "DEEP_ARCHIVE_STAGING_STORAGE"
    '''
    :stability: experimental
    '''
    DEEP_ARCHIVE_STORAGE = "DEEP_ARCHIVE_STORAGE"
    '''
    :stability: experimental
    '''
    GLACIER_OBJECT_OVERHEAD = "GLACIER_OBJECT_OVERHEAD"
    '''
    :stability: experimental
    '''
    GLACIER_S3_OBJECT_OVERHEAD = "GLACIER_S3_OBJECT_OVERHEAD"
    '''
    :stability: experimental
    '''
    GLACIER_STAGING_STORAGE = "GLACIER_STAGING_STORAGE"
    '''
    :stability: experimental
    '''
    GLACIER_STORAGE = "GLACIER_STORAGE"
    '''
    :stability: experimental
    '''
    INTELLIGENT_TIERING_FA_STORAGE = "INTELLIGENT_TIERING_FA_STORAGE"
    '''
    :stability: experimental
    '''
    INTELLIGENT_TIERING_IA_STORAGE = "INTELLIGENT_TIERING_IA_STORAGE"
    '''
    :stability: experimental
    '''
    ONE_ZONE_IA_SIZE_OVERHEAD = "ONE_ZONE_IA_SIZE_OVERHEAD"
    '''
    :stability: experimental
    '''
    ONE_ZONE_IA_STORAGE = "ONE_ZONE_IA_STORAGE"
    '''
    :stability: experimental
    '''
    REDUCED_REDUNDANCY_STORAGE = "REDUCED_REDUNDANCY_STORAGE"
    '''
    :stability: experimental
    '''
    STANDARD_IA_SIZE_OVERHEAD = "STANDARD_IA_SIZE_OVERHEAD"
    '''
    :stability: experimental
    '''
    STANDARD_IA_STORAGE = "STANDARD_IA_STORAGE"
    '''
    :stability: experimental
    '''
    STANDARD_STORAGE = "STANDARD_STORAGE"
    '''
    :stability: experimental
    '''


class SyntheticsCanaryMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SyntheticsCanaryMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param canary: (experimental) CloudWatch Canary to monitor.
        :param rate_computation_method: (experimental) Method used to calculate relative rates. Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f83a831814f419f0eaa70054e62e47bf6a5696874c2ea319b169366ad94f3291)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = SyntheticsCanaryMetricFactoryProps(
            canary=canary,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metric4xxErrorCount")
    def metric4xx_error_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4xxErrorCount", []))

    @jsii.member(jsii_name="metric4xxErrorRate")
    def metric4xx_error_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4xxErrorRate", []))

    @jsii.member(jsii_name="metric5xxFaultCount")
    def metric5xx_fault_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5xxFaultCount", []))

    @jsii.member(jsii_name="metric5xxFaultRate")
    def metric5xx_fault_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5xxFaultRate", []))

    @jsii.member(jsii_name="metricLatencyAverageInMillis")
    def metric_latency_average_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyAverageInMillis", []))

    @jsii.member(jsii_name="metricSuccessInPercent")
    def metric_success_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricSuccessInPercent", []))

    @builtins.property
    @jsii.member(jsii_name="canary")
    def _canary(self) -> _aws_cdk_aws_synthetics_ceddda9d.Canary:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_synthetics_ceddda9d.Canary, jsii.get(self, "canary"))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SyntheticsCanaryMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "canary": "canary",
        "rate_computation_method": "rateComputationMethod",
    },
)
class SyntheticsCanaryMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param canary: (experimental) CloudWatch Canary to monitor.
        :param rate_computation_method: (experimental) Method used to calculate relative rates. Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ee0704c81a58fffb63613f59492fe7f33dc1f6f99b4d2c55e1170f409ae56014)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument canary", value=canary, expected_type=type_hints["canary"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "canary": canary,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def canary(self) -> _aws_cdk_aws_synthetics_ceddda9d.Canary:
        '''(experimental) CloudWatch Canary to monitor.

        :stability: experimental
        '''
        result = self._values.get("canary")
        assert result is not None, "Required property 'canary' is missing"
        return typing.cast(_aws_cdk_aws_synthetics_ceddda9d.Canary, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''(experimental) Method used to calculate relative rates.

        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SyntheticsCanaryMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SyntheticsCanaryMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.SyntheticsCanaryMonitoring",
):
    '''(experimental) Monitoring for CloudWatch Synthetics Canaries.

    :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries.html
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param canary: (experimental) CloudWatch Canary to monitor.
        :param rate_computation_method: (experimental) Method used to calculate relative rates. Default: - average
        :param add4xx_error_count_alarm: 
        :param add4xx_error_rate_alarm: 
        :param add5xx_fault_count_alarm: 
        :param add5xx_fault_rate_alarm: 
        :param add_average_latency_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce0c24f90bbc5a2e23383abf2a097520c92a4992d21bfdc5e4ea2eca1b51526c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = SyntheticsCanaryMonitoringProps(
            canary=canary,
            rate_computation_method=rate_computation_method,
            add4xx_error_count_alarm=add4xx_error_count_alarm,
            add4xx_error_rate_alarm=add4xx_error_rate_alarm,
            add5xx_fault_count_alarm=add5xx_fault_count_alarm,
            add5xx_fault_rate_alarm=add5xx_fault_rate_alarm,
            add_average_latency_alarm=add_average_latency_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cede60cdf9327d0e34d1f11cc818d9920c5300cad19e5239dbc8c9869fe61abc)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19a8bc43afad7b2c64ace564c28500680e7cfb9a4ffea72c48fdd830fe8e400e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c87bdac6016ca10915835e44da0513eec54cf29cb4cddb6e6bdfa591b858f20)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="averageLatencyMetric")
    def average_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "averageLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorCountMetric")
    def error_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "errorCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateMetric")
    def error_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "errorRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="faultCountMetric")
    def fault_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "faultCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="faultRateMetric")
    def fault_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "faultRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="humanReadableName")
    def human_readable_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "humanReadableName"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))


class TaskHealthAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.TaskHealthAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8abc53b479ea1ce3fd1bd796a1572f64c5fe5ac8555cb703ff385f3a092adbd)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addAvailabilityAlarm")
    def add_availability_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["AvailabilityThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__70242af415cd005ce07c69f3db252cb91b7eefd7b43edbdfc0203045ce2fb9f2)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addAvailabilityAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addHealthyTaskCountAlarm")
    def add_healthy_task_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ec3ad2da6c605cc286e896456fb5d7d40b3c4edc4aa6cda485637ac3e2ab416)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addHealthyTaskCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addHealthyTaskPercentAlarm")
    def add_healthy_task_percent_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__92087bd36fc157e2e3cfc3be729a78c6c98b0255dd27b4cf9b9761e565478481)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addHealthyTaskPercentAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinRunningTaskCountAlarm")
    def add_min_running_task_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0df622c2b17d3fbd9a7c688744aefa5cb984dc2ae08ee8431c13859a28592342)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinRunningTaskCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addRunningTaskCountAlarm")
    def add_running_task_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9f9933456ae353bac0b6521489b3d18def7a5a38f7c56f74adf0644034bf4afb)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addRunningTaskCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addRunningTaskRateAlarm")
    def add_running_task_rate_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e722af6a58321750df864976f87117022091fc84264aef3b506d92387c402ce8)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addRunningTaskRateAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addUnhealthyTaskCountAlarm")
    def add_unhealthy_task_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UnhealthyTaskCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec222d3d9c17a3075ff4e84028ef924258958cf5279ea15088be678c6c36c74d)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addUnhealthyTaskCountAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ThrottledEventsThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_throttled_events_threshold": "maxThrottledEventsThreshold",
    },
)
class ThrottledEventsThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_throttled_events_threshold: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_throttled_events_threshold: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__600be463be20882979f64fe4491211b0ad7e763e45ca042482a011503fc3c6f6)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_throttled_events_threshold", value=max_throttled_events_threshold, expected_type=type_hints["max_throttled_events_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_throttled_events_threshold": max_throttled_events_threshold,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_throttled_events_threshold(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_throttled_events_threshold")
        assert result is not None, "Required property 'max_throttled_events_threshold' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ThrottledEventsThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ThroughputAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ThroughputAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa708301faa16e8f282b560afc526ec8613e86dab97a3148d8231ac195f1bb26)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMinProcessedBytesAlarm")
    def add_min_processed_bytes_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__294291652d3e6afa7254c53602461adb08859cfb9af6e2fb799a266c2761735f)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinProcessedBytesAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class TopicAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.TopicAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cf1c912c1cfecf9d0c46dbd6c4aa0d09ae4391c962a37ebffac1924ae65ebd7)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxMessagesPublishedAlarm")
    def add_max_messages_published_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__333ac4e95737b1b3223a0874287a7cbe1f32418261e3b87a611bcd7666d1e3b5)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxMessagesPublishedAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMessageNotificationsFailedAlarm")
    def add_message_notifications_failed_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0927b08d6781860c82f33aabd327e8385a811bdc45dbb4406a8fdba19f59142)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMessageNotificationsFailedAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinMessagesPublishedAlarm")
    def add_min_messages_published_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__27b890b7f9c561584239aef09437ef2049e1d751cc47ef1fded39c1a786a8773)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinMessagesPublishedAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


class TpsAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.TpsAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9701eaaf292ea329990ee38531c3291c3e7fbe5d5f36323134c193bd9ac9b13d)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxTpsAlarm")
    def add_max_tps_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84b2360f69539ac7bb6a6d68748f4e1f18500bdd71fb1a3cc7f0fa37f5261a7a)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxTpsAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinTpsAlarm")
    def add_min_tps_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a24fe3364597b00efb14bf4983d4065532826e7b0b700f908b7049bc95e5022)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinTpsAlarm", [metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.UnhealthyTaskCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_unhealthy_tasks": "maxUnhealthyTasks",
    },
)
class UnhealthyTaskCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_unhealthy_tasks: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_unhealthy_tasks: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e61208c7f53894f9ee47dc958f49741d8dd5345dd6ebfba8e4b29d1b4416201e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_unhealthy_tasks", value=max_unhealthy_tasks, expected_type=type_hints["max_unhealthy_tasks"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_unhealthy_tasks": max_unhealthy_tasks,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_unhealthy_tasks(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_unhealthy_tasks")
        assert result is not None, "Required property 'max_unhealthy_tasks' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "UnhealthyTaskCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class UsageAlarmFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.UsageAlarmFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self, alarm_factory: AlarmFactory) -> None:
        '''
        :param alarm_factory: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6024c89aa647570c2d472db05673d44c0185218b92a76118d2e35da2e546cc58)
            check_type(argname="argument alarm_factory", value=alarm_factory, expected_type=type_hints["alarm_factory"])
        jsii.create(self.__class__, self, [alarm_factory])

    @jsii.member(jsii_name="addMaxCountAlarm")
    def add_max_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__456af966814b00fa77d8603b83ed545f2565841a9aa89993943cdc90339dc73e)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxCpuUsagePercentAlarm")
    def add_max_cpu_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
        usage_type: typing.Optional["UsageType"] = None,
        additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -
        :param usage_type: -
        :param additional_alarm_name_suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__994aad6de5d7f078d766fc2755e206840482d4e8bebb5fdd28c6b3d7fbd32e64)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument usage_type", value=usage_type, expected_type=type_hints["usage_type"])
            check_type(argname="argument additional_alarm_name_suffix", value=additional_alarm_name_suffix, expected_type=type_hints["additional_alarm_name_suffix"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxCpuUsagePercentAlarm", [percent_metric, props, disambiguator, usage_type, additional_alarm_name_suffix]))

    @jsii.member(jsii_name="addMaxDiskUsagePercentAlarm")
    def add_max_disk_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b368ff0d337f1d428df2b41fa943b4c723a47f6d2f649273bfdd84ca0d24257)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxDiskUsagePercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxFileDescriptorPercentAlarm")
    def add_max_file_descriptor_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25287e087b4a879261e5de282f2b9718bd0ca38d97f153236f47619d18bfd5bd)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxFileDescriptorPercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxHeapMemoryAfterGCUsagePercentAlarm")
    def add_max_heap_memory_after_gc_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d9f998f94e5c5a53b2edfd13e376a5677454ebf0374dec19169eb51abc6465a)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxHeapMemoryAfterGCUsagePercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxMasterCpuUsagePercentAlarm")
    def add_max_master_cpu_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__287b250c67bf52f1eee63e27ac669c68cba0c3ffe49bbe045e0ba80e0dabebe1)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxMasterCpuUsagePercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxMasterMemoryUsagePercentAlarm")
    def add_max_master_memory_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__685cb74f7702a8fd45d2866542bb0dece98587c28e475b20bbd0d6269b90545b)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxMasterMemoryUsagePercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxMemoryUsagePercentAlarm")
    def add_max_memory_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7b8af26b836c7f4d9bf0ced99829735b3ebbe68dc46272b876a356d922aafc9)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxMemoryUsagePercentAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxThreadCountUsageAlarm")
    def add_max_thread_count_usage_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f7096d8940ef584f4ec97b5eb157b99dde6d685326c56d1c1fbd200beac086a)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxThreadCountUsageAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMaxUsageCountAlarm")
    def add_max_usage_count_alarm(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageCountThreshold", typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param metric: -
        :param props: -
        :param disambiguator: -

        :deprecated: Use {@link addMaxCountAlarm} instead.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa8162cb03b135be07bbd84a562567b7a8e2c20bd2af5c9fceb33323ad5b1852)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMaxUsageCountAlarm", [metric, props, disambiguator]))

    @jsii.member(jsii_name="addMemoryUsagePercentAlarm")
    def add_memory_usage_percent_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union["UsageThreshold", typing.Dict[builtins.str, typing.Any]],
        usage_type: "UsageType",
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param usage_type: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74974b917d51926e118b2ad2d5cfe13d0cd5f0dcc7a87a6c8b13ed595ddfbc40)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument usage_type", value=usage_type, expected_type=type_hints["usage_type"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMemoryUsagePercentAlarm", [percent_metric, props, usage_type, disambiguator]))

    @jsii.member(jsii_name="addMinCountAlarm")
    def add_min_count_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9375a9c28084134036902936452f624af94a5bbf037f469581b283365a77db5c)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinCountAlarm", [percent_metric, props, disambiguator]))

    @jsii.member(jsii_name="addMinUsageCountAlarm")
    def add_min_usage_count_alarm(
        self,
        percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        props: typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> AlarmWithAnnotation:
        '''
        :param percent_metric: -
        :param props: -
        :param disambiguator: -

        :deprecated: Use {@link addMinCountAlarm} instead.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4500d9b03bc8c08fe2815b3f58023c9cb2c226a893bb816990e629a71d814dd5)
            check_type(argname="argument percent_metric", value=percent_metric, expected_type=type_hints["percent_metric"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(AlarmWithAnnotation, jsii.invoke(self, "addMinUsageCountAlarm", [percent_metric, props, disambiguator]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def _alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.UsageCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_usage_count": "maxUsageCount",
    },
)
class UsageCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_usage_count: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_usage_count: 

        :deprecated: Use MaxUsageCountThreshold instead.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__945929fe315cbfa9072390f81c1eda11eea270536d078942376af0620d93c151)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_usage_count", value=max_usage_count, expected_type=type_hints["max_usage_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_usage_count": max_usage_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_usage_count(self) -> jsii.Number:
        '''
        :stability: deprecated
        '''
        result = self._values.get("max_usage_count")
        assert result is not None, "Required property 'max_usage_count' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "UsageCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.UsageThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_usage_percent": "maxUsagePercent",
    },
)
class UsageThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_usage_percent: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_usage_percent: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__062bb0fb889d69b2a6dd92c73e9d906466c191caa9c25cd9d8407f2e76339a2e)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_usage_percent", value=max_usage_percent, expected_type=type_hints["max_usage_percent"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_usage_percent": max_usage_percent,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_usage_percent(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_usage_percent")
        assert result is not None, "Required property 'max_usage_percent' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "UsageThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="cdk-monitoring-constructs.UsageType")
class UsageType(enum.Enum):
    '''
    :stability: experimental
    '''

    P50 = "P50"
    '''
    :stability: experimental
    '''
    P70 = "P70"
    '''
    :stability: experimental
    '''
    P90 = "P90"
    '''
    :stability: experimental
    '''
    P99 = "P99"
    '''
    :stability: experimental
    '''
    P999 = "P999"
    '''
    :stability: experimental
    '''
    P9999 = "P9999"
    '''
    :stability: experimental
    '''
    P100 = "P100"
    '''
    :stability: experimental
    '''
    AVERAGE = "AVERAGE"
    '''
    :stability: experimental
    '''
    MAX = "MAX"
    '''
    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.UserProvidedNames",
    jsii_struct_bases=[],
    name_mapping={
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
    },
)
class UserProvidedNames:
    def __init__(
        self,
        *,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__840fd490893dca69a0d2f0937cb6370b475f368b3827e45ea0bcce53f7620aac)
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "UserProvidedNames(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class WafV2MetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.WafV2MetricFactory",
):
    '''(experimental) https://docs.aws.amazon.com/waf/latest/developerguide/monitoring-cloudwatch.html.

    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param acl: (experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00b3ae71ef5bb8a55bd6886b3abc9219bcf416aa0759268217a9acec63175f47)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = WafV2MetricFactoryProps(acl=acl, account=account, region=region)

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricAllowedRequests")
    def metric_allowed_requests(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricAllowedRequests", []))

    @jsii.member(jsii_name="metricBlockedRequests")
    def metric_blocked_requests(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricBlockedRequests", []))

    @jsii.member(jsii_name="metricBlockedRequestsRate")
    def metric_blocked_requests_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricBlockedRequestsRate", []))

    @builtins.property
    @jsii.member(jsii_name="dimensions")
    def _dimensions(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "dimensions"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.WafV2MetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={"account": "account", "region": "region", "acl": "acl"},
)
class WafV2MetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param acl: (experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7dc04f9ab59e328eed1822811e91892bbd63f15c038d7f017032c88e5ed35692)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "acl": acl,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL:
        '''(experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.

        :stability: experimental
        '''
        result = self._values.get("acl")
        assert result is not None, "Required property 'acl' is missing"
        return typing.cast(_aws_cdk_aws_wafv2_ceddda9d.CfnWebACL, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "WafV2MetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class WafV2Monitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.WafV2Monitoring",
):
    '''(experimental) Monitoring for AWS Web Application Firewall.

    :see: https://docs.aws.amazon.com/waf/latest/developerguide/monitoring-cloudwatch.html
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_blocked_requests_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_blocked_requests_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_blocked_requests_count_alarm: 
        :param add_blocked_requests_rate_alarm: 
        :param acl: (experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ffa7d244eb495c4ee5b9ba523d94533cca861a86870c025e1e574e55346e4da)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = WafV2MonitoringProps(
            add_blocked_requests_count_alarm=add_blocked_requests_count_alarm,
            add_blocked_requests_rate_alarm=add_blocked_requests_rate_alarm,
            acl=acl,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createAllowedRequestsWidget")
    def create_allowed_requests_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__082ce58b14094d5c253b34e1566acc04757c81d4f7bf8d0831d3b051b2ecb406)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createAllowedRequestsWidget", [width, height]))

    @jsii.member(jsii_name="createBlockedRequestsRateWidget")
    def create_blocked_requests_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30836197905661f1cd2bd7e059ca9e6c296788cad72a9dff64546df895700fa5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createBlockedRequestsRateWidget", [width, height]))

    @jsii.member(jsii_name="createBlockedRequestsWidget")
    def create_blocked_requests_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34e102fcb99746157acd883e72313acfe264c5173b411edb6c361d8f265b01a5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createBlockedRequestsWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="allowedRequestsMetric")
    def allowed_requests_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "allowedRequestsMetric"))

    @builtins.property
    @jsii.member(jsii_name="blockedRequestsMetric")
    def blocked_requests_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "blockedRequestsMetric"))

    @builtins.property
    @jsii.member(jsii_name="blockedRequestsRateMetric")
    def blocked_requests_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "blockedRequestsRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="humanReadableName")
    def human_readable_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "humanReadableName"))


@jsii.implements(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric)
class XaxrMathExpression(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.XaxrMathExpression",
):
    '''(deprecated) Custom wrapper class for MathExpression that supports account and region specification.

    :deprecated: Use MathExpression from aws-cdk-lib/aws-cloudwatch instead.

    :see: https://github.com/aws/aws-cdk/issues/9039
    :stability: deprecated
    '''

    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        expression: builtins.str,
        using_metrics: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]] = None,
        color: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        search_account: typing.Optional[builtins.str] = None,
        search_region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) (experimental) Account which this metric comes from. Default: - Deployment account.
        :param region: (experimental) (experimental) Region which this metric comes from. Default: - Deployment region.
        :param expression: The expression defining the metric. When an expression contains a SEARCH function, it cannot be used within an Alarm.
        :param using_metrics: The metrics used in the expression, in a map. The key is the identifier that represents the given metric in the expression, and the value is the actual Metric object. Default: - Empty map.
        :param color: Color for this metric when added to a Graph in a Dashboard. Default: - Automatic color
        :param label: Label for this expression when added to a Graph in a Dashboard. If this expression evaluates to more than one time series (for example, through the use of ``METRICS()`` or ``SEARCH()`` expressions), each time series will appear in the graph using a combination of the expression label and the individual metric label. Specify the empty string (``''``) to suppress the expression label and only keep the metric label. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. If the math expression produces more than one time series, the maximum will be shown for each individual time series produce by this math expression. Default: - Expression value is used as label
        :param period: The period over which the expression's statistics are applied. This period overrides all periods in the metrics used in this math expression. Default: Duration.minutes(5)
        :param search_account: Account to evaluate search expressions within. Specifying a searchAccount has no effect to the account used for metrics within the expression (passed via usingMetrics). Default: - Deployment account.
        :param search_region: Region to evaluate search expressions within. Specifying a searchRegion has no effect to the region used for metrics within the expression (passed via usingMetrics). Default: - Deployment region.

        :stability: deprecated
        '''
        props = XaxrMathExpressionProps(
            account=account,
            region=region,
            expression=expression,
            using_metrics=using_metrics,
            color=color,
            label=label,
            period=period,
            search_account=search_account,
            search_region=search_region,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="toMetricConfig")
    def to_metric_config(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.MetricConfig:
        '''(deprecated) Inspect the details of the metric object.

        :deprecated: Use MathExpression from aws-cdk-lib/aws-cloudwatch instead.

        :stability: deprecated
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.MetricConfig, jsii.invoke(self, "toMetricConfig", []))

    @jsii.member(jsii_name="with")
    def with_(
        self,
        *,
        color: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        search_account: typing.Optional[builtins.str] = None,
        search_region: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IMetric:
        '''
        :param color: Color for this metric when added to a Graph in a Dashboard. Default: - Automatic color
        :param label: Label for this expression when added to a Graph in a Dashboard. If this expression evaluates to more than one time series (for example, through the use of ``METRICS()`` or ``SEARCH()`` expressions), each time series will appear in the graph using a combination of the expression label and the individual metric label. Specify the empty string (``''``) to suppress the expression label and only keep the metric label. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. If the math expression produces more than one time series, the maximum will be shown for each individual time series produce by this math expression. Default: - Expression value is used as label
        :param period: The period over which the expression's statistics are applied. This period overrides all periods in the metrics used in this math expression. Default: Duration.minutes(5)
        :param search_account: Account to evaluate search expressions within. Specifying a searchAccount has no effect to the account used for metrics within the expression (passed via usingMetrics). Default: - Deployment account.
        :param search_region: Region to evaluate search expressions within. Specifying a searchRegion has no effect to the region used for metrics within the expression (passed via usingMetrics). Default: - Deployment region.

        :deprecated: Use MathExpression from aws-cdk-lib/aws-cloudwatch instead.

        :stability: deprecated
        '''
        options = _aws_cdk_aws_cloudwatch_ceddda9d.MathExpressionOptions(
            color=color,
            label=label,
            period=period,
            search_account=search_account,
            search_region=search_region,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric, jsii.invoke(self, "with", [options]))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.XaxrMathExpressionProps",
    jsii_struct_bases=[_aws_cdk_aws_cloudwatch_ceddda9d.MathExpressionProps],
    name_mapping={
        "color": "color",
        "label": "label",
        "period": "period",
        "search_account": "searchAccount",
        "search_region": "searchRegion",
        "expression": "expression",
        "using_metrics": "usingMetrics",
        "account": "account",
        "region": "region",
    },
)
class XaxrMathExpressionProps(_aws_cdk_aws_cloudwatch_ceddda9d.MathExpressionProps):
    def __init__(
        self,
        *,
        color: typing.Optional[builtins.str] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        search_account: typing.Optional[builtins.str] = None,
        search_region: typing.Optional[builtins.str] = None,
        expression: builtins.str,
        using_metrics: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Custom wrapper class for MathExpressionProps that supports account and region customization.

        :param color: Color for this metric when added to a Graph in a Dashboard. Default: - Automatic color
        :param label: Label for this expression when added to a Graph in a Dashboard. If this expression evaluates to more than one time series (for example, through the use of ``METRICS()`` or ``SEARCH()`` expressions), each time series will appear in the graph using a combination of the expression label and the individual metric label. Specify the empty string (``''``) to suppress the expression label and only keep the metric label. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. If the math expression produces more than one time series, the maximum will be shown for each individual time series produce by this math expression. Default: - Expression value is used as label
        :param period: The period over which the expression's statistics are applied. This period overrides all periods in the metrics used in this math expression. Default: Duration.minutes(5)
        :param search_account: Account to evaluate search expressions within. Specifying a searchAccount has no effect to the account used for metrics within the expression (passed via usingMetrics). Default: - Deployment account.
        :param search_region: Region to evaluate search expressions within. Specifying a searchRegion has no effect to the region used for metrics within the expression (passed via usingMetrics). Default: - Deployment region.
        :param expression: The expression defining the metric. When an expression contains a SEARCH function, it cannot be used within an Alarm.
        :param using_metrics: The metrics used in the expression, in a map. The key is the identifier that represents the given metric in the expression, and the value is the actual Metric object. Default: - Empty map.
        :param account: (experimental) (experimental) Account which this metric comes from. Default: - Deployment account.
        :param region: (experimental) (experimental) Region which this metric comes from. Default: - Deployment region.

        :see: https://github.com/aws/aws-cdk/issues/9039
        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae44dc3f7f4671f357c2c9abda0ac63738adb722a9c07a401cdd1f0e5cd59b3f)
            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
            check_type(argname="argument label", value=label, expected_type=type_hints["label"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument search_account", value=search_account, expected_type=type_hints["search_account"])
            check_type(argname="argument search_region", value=search_region, expected_type=type_hints["search_region"])
            check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
            check_type(argname="argument using_metrics", value=using_metrics, expected_type=type_hints["using_metrics"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "expression": expression,
        }
        if color is not None:
            self._values["color"] = color
        if label is not None:
            self._values["label"] = label
        if period is not None:
            self._values["period"] = period
        if search_account is not None:
            self._values["search_account"] = search_account
        if search_region is not None:
            self._values["search_region"] = search_region
        if using_metrics is not None:
            self._values["using_metrics"] = using_metrics
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def color(self) -> typing.Optional[builtins.str]:
        '''Color for this metric when added to a Graph in a Dashboard.

        :default: - Automatic color
        '''
        result = self._values.get("color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def label(self) -> typing.Optional[builtins.str]:
        '''Label for this expression when added to a Graph in a Dashboard.

        If this expression evaluates to more than one time series (for
        example, through the use of ``METRICS()`` or ``SEARCH()`` expressions),
        each time series will appear in the graph using a combination of the
        expression label and the individual metric label. Specify the empty
        string (``''``) to suppress the expression label and only keep the
        metric label.

        You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_
        to show summary information about the displayed time series
        in the legend. For example, if you use::

           [max: ${MAX}] MyMetric

        As the metric label, the maximum value in the visible range will
        be shown next to the time series name in the graph's legend. If the
        math expression produces more than one time series, the maximum
        will be shown for each individual time series produce by this
        math expression.

        :default: - Expression value is used as label
        '''
        result = self._values.get("label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''The period over which the expression's statistics are applied.

        This period overrides all periods in the metrics used in this
        math expression.

        :default: Duration.minutes(5)
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def search_account(self) -> typing.Optional[builtins.str]:
        '''Account to evaluate search expressions within.

        Specifying a searchAccount has no effect to the account used
        for metrics within the expression (passed via usingMetrics).

        :default: - Deployment account.
        '''
        result = self._values.get("search_account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def search_region(self) -> typing.Optional[builtins.str]:
        '''Region to evaluate search expressions within.

        Specifying a searchRegion has no effect to the region used
        for metrics within the expression (passed via usingMetrics).

        :default: - Deployment region.
        '''
        result = self._values.get("search_region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def expression(self) -> builtins.str:
        '''The expression defining the metric.

        When an expression contains a SEARCH function, it cannot be used
        within an Alarm.
        '''
        result = self._values.get("expression")
        assert result is not None, "Required property 'expression' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def using_metrics(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]]:
        '''The metrics used in the expression, in a map.

        The key is the identifier that represents the given metric in the
        expression, and the value is the actual Metric object.

        :default: - Empty map.
        '''
        result = self._values.get("using_metrics")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) (experimental) Account which this metric comes from.

        :default: - Deployment account.

        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) (experimental) Region which this metric comes from.

        :default: - Deployment region.

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "XaxrMathExpressionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmActionStrategyProps",
    jsii_struct_bases=[AlarmMetadata],
    name_mapping={
        "action": "action",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "dedupe_string": "dedupeString",
        "disambiguator": "disambiguator",
        "alarm": "alarm",
    },
)
class AlarmActionStrategyProps(AlarmMetadata):
    def __init__(
        self,
        *,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
    ) -> None:
        '''(experimental) Properties necessary to append actions to an alarm.

        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 
        :param alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0ad60ad49086bddfe7d3aa14d36a9ba4494adc2ecc73aa5f0ccfa11ce90206b)
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument alarm", value=alarm, expected_type=type_hints["alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "action": action,
            "alarm": alarm,
        }
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if dedupe_string is not None:
            self._values["dedupe_string"] = dedupe_string
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator

    @builtins.property
    def action(self) -> IAlarmActionStrategy:
        '''
        :stability: experimental
        '''
        result = self._values.get("action")
        assert result is not None, "Required property 'action' is missing"
        return typing.cast(IAlarmActionStrategy, result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def dedupe_string(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm")
        assert result is not None, "Required property 'alarm' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmActionStrategyProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AlarmAnnotationStrategyProps",
    jsii_struct_bases=[AlarmMetadata],
    name_mapping={
        "action": "action",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "dedupe_string": "dedupeString",
        "disambiguator": "disambiguator",
        "alarm": "alarm",
        "comparison_operator": "comparisonOperator",
        "datapoints_to_alarm": "datapointsToAlarm",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric": "metric",
        "threshold": "threshold",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
    },
)
class AlarmAnnotationStrategyProps(AlarmMetadata):
    def __init__(
        self,
        *,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ff5cb942cbeee514e41e8c557fbdad8dd19936c2ba21c01ba16dec78592fb6f)
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
            check_type(argname="argument alarm", value=alarm, expected_type=type_hints["alarm"])
            check_type(argname="argument comparison_operator", value=comparison_operator, expected_type=type_hints["comparison_operator"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument threshold", value=threshold, expected_type=type_hints["threshold"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "action": action,
            "alarm": alarm,
            "comparison_operator": comparison_operator,
            "datapoints_to_alarm": datapoints_to_alarm,
            "evaluation_periods": evaluation_periods,
            "fill_alarm_range": fill_alarm_range,
            "metric": metric,
            "threshold": threshold,
        }
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if dedupe_string is not None:
            self._values["dedupe_string"] = dedupe_string
        if disambiguator is not None:
            self._values["disambiguator"] = disambiguator
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility

    @builtins.property
    def action(self) -> IAlarmActionStrategy:
        '''
        :stability: experimental
        '''
        result = self._values.get("action")
        assert result is not None, "Required property 'action' is missing"
        return typing.cast(IAlarmActionStrategy, result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def dedupe_string(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("dedupe_string")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disambiguator(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("disambiguator")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.Alarm:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm")
        assert result is not None, "Required property 'alarm' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Alarm, result)

    @builtins.property
    def comparison_operator(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator:
        '''
        :stability: experimental
        '''
        result = self._values.get("comparison_operator")
        assert result is not None, "Required property 'comparison_operator' is missing"
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator, result)

    @builtins.property
    def datapoints_to_alarm(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        assert result is not None, "Required property 'datapoints_to_alarm' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def evaluation_periods(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        assert result is not None, "Required property 'evaluation_periods' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def fill_alarm_range(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        assert result is not None, "Required property 'fill_alarm_range' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        result = self._values.get("metric")
        assert result is not None, "Required property 'metric' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], result)

    @builtins.property
    def threshold(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("threshold")
        assert result is not None, "Required property 'threshold' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AlarmAnnotationStrategyProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IAlarmNamingStrategy)
class AlarmNamingStrategy(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AlarmNamingStrategy",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        global_prefix: builtins.str,
        local_prefix: builtins.str,
        dedupe_string_strategy: typing.Optional[IAlarmDedupeStringProcessor] = None,
    ) -> None:
        '''
        :param global_prefix: -
        :param local_prefix: -
        :param dedupe_string_strategy: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf95e8544d24099bb0e42c2f5f4ec3fa3be5861dcac0ec558abf083ee3bdf246)
            check_type(argname="argument global_prefix", value=global_prefix, expected_type=type_hints["global_prefix"])
            check_type(argname="argument local_prefix", value=local_prefix, expected_type=type_hints["local_prefix"])
            check_type(argname="argument dedupe_string_strategy", value=dedupe_string_strategy, expected_type=type_hints["dedupe_string_strategy"])
        jsii.create(self.__class__, self, [global_prefix, local_prefix, dedupe_string_strategy])

    @jsii.member(jsii_name="getDedupeString")
    def get_dedupe_string(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[builtins.str]:
        '''(experimental) Dedupe string resolved like this: - If "dedupeStringOverride" is defined for an alarm, it will be used as a dedupe string.

        - If "alarmDedupeStringSuffix" from the alarm factory is defined, "GlobalPrefix-LocalPrefix-AlarmDedupeStringSuffix" will be used as a dedupe string.
        - Otherwise, the alarm dedupe string will not be set.
          If a dedupe string strategy is set, it will be used to process the final string.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "getDedupeString", [props]))

    @jsii.member(jsii_name="getName")
    def get_name(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Alarm name is resolved like this: - If "alarmNameOverride" is defined for an alarm, it will be used as alarm name.

        - Otherwise, the alarm name will be generated by joining: global prefix, local prefix, alarm name suffix, disambiguator.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(builtins.str, jsii.invoke(self, "getName", [props]))

    @jsii.member(jsii_name="getWidgetLabel")
    def get_widget_label(
        self,
        *,
        alarm_name_suffix: builtins.str,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) How to generate the label for the alarm displayed on a widget.

        :param alarm_name_suffix: 
        :param alarm_dedupe_string_suffix: 
        :param alarm_name_override: 
        :param dedupe_string_override: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmNamingInput(
            alarm_name_suffix=alarm_name_suffix,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_name_override=alarm_name_override,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
        )

        return typing.cast(builtins.str, jsii.invoke(self, "getWidgetLabel", [props]))

    @jsii.member(jsii_name="joinDistinct")
    def _join_distinct(
        self,
        parts: typing.Sequence[builtins.str],
        separator: builtins.str,
    ) -> builtins.str:
        '''
        :param parts: -
        :param separator: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11d6898c3b5506203798a7f791daee2a4e439473de0a41e20655d181febd012a)
            check_type(argname="argument parts", value=parts, expected_type=type_hints["parts"])
            check_type(argname="argument separator", value=separator, expected_type=type_hints["separator"])
        return typing.cast(builtins.str, jsii.invoke(self, "joinDistinct", [parts, separator]))

    @builtins.property
    @jsii.member(jsii_name="dedupeStringStrategy")
    def _dedupe_string_strategy(self) -> IAlarmDedupeStringProcessor:
        '''
        :stability: experimental
        '''
        return typing.cast(IAlarmDedupeStringProcessor, jsii.get(self, "dedupeStringStrategy"))

    @builtins.property
    @jsii.member(jsii_name="globalPrefix")
    def _global_prefix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "globalPrefix"))

    @builtins.property
    @jsii.member(jsii_name="localPrefix")
    def _local_prefix(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "localPrefix"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AnomalyDetectionThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "alarm_when_above_the_band": "alarmWhenAboveTheBand",
        "alarm_when_below_the_band": "alarmWhenBelowTheBand",
        "standard_deviation_for_alarm": "standardDeviationForAlarm",
        "additional_description": "additionalDescription",
    },
)
class AnomalyDetectionThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        alarm_when_above_the_band: builtins.bool,
        alarm_when_below_the_band: builtins.bool,
        standard_deviation_for_alarm: jsii.Number,
        additional_description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param alarm_when_above_the_band: 
        :param alarm_when_below_the_band: 
        :param standard_deviation_for_alarm: 
        :param additional_description: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e24e91b81fc2fa966218c11a02883b1bcbd8696036153b3d0c6166470c03df4)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument alarm_when_above_the_band", value=alarm_when_above_the_band, expected_type=type_hints["alarm_when_above_the_band"])
            check_type(argname="argument alarm_when_below_the_band", value=alarm_when_below_the_band, expected_type=type_hints["alarm_when_below_the_band"])
            check_type(argname="argument standard_deviation_for_alarm", value=standard_deviation_for_alarm, expected_type=type_hints["standard_deviation_for_alarm"])
            check_type(argname="argument additional_description", value=additional_description, expected_type=type_hints["additional_description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_when_above_the_band": alarm_when_above_the_band,
            "alarm_when_below_the_band": alarm_when_below_the_band,
            "standard_deviation_for_alarm": standard_deviation_for_alarm,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override
        if additional_description is not None:
            self._values["additional_description"] = additional_description

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def alarm_when_above_the_band(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_when_above_the_band")
        assert result is not None, "Required property 'alarm_when_above_the_band' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def alarm_when_below_the_band(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_when_below_the_band")
        assert result is not None, "Required property 'alarm_when_below_the_band' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def standard_deviation_for_alarm(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("standard_deviation_for_alarm")
        assert result is not None, "Required property 'standard_deviation_for_alarm' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def additional_description(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("additional_description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AnomalyDetectionThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ApiGatewayMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ApiGatewayMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param api: (experimental) API to monitor.
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - prod
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9265647c98954edacf49deb7db52bee562d8a481ca25c2973388e59c3656d990)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = ApiGatewayMetricFactoryProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metric4XXErrorCount")
    def metric4_xx_error_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4XXErrorCount", []))

    @jsii.member(jsii_name="metric4XXErrorRate")
    def metric4_xx_error_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4XXErrorRate", []))

    @jsii.member(jsii_name="metric5XXFaultCount")
    def metric5_xx_fault_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5XXFaultCount", []))

    @jsii.member(jsii_name="metric5XXFaultRate")
    def metric5_xx_fault_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5XXFaultRate", []))

    @jsii.member(jsii_name="metricInvocationCount")
    def metric_invocation_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationCount", []))

    @jsii.member(jsii_name="metricInvocationRate")
    def metric_invocation_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationRate", []))

    @jsii.member(jsii_name="metricLatencyInMillis")
    def metric_latency_in_millis(
        self,
        latency_type: LatencyType,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2933aca068332399ea22458abe47d58325c3bf76dca46e878ecee73de9b39457)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricLatencyP50InMillis")
    def metric_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricLatencyP90InMillis")
    def metric_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricLatencyP99InMillis")
    def metric_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricTps")
    def metric_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricInvocationRate

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTps", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="fillTpsWithZeroes")
    def _fill_tps_with_zeroes(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "fillTpsWithZeroes"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "api": "api",
        "api_method": "apiMethod",
        "api_resource": "apiResource",
        "api_stage": "apiStage",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class ApiGatewayMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param api: (experimental) API to monitor.
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - prod
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1b780ea37d9219999048c1925625d47526eb003c3a69d33b0eab72fa5e80b83)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument api_method", value=api_method, expected_type=type_hints["api_method"])
            check_type(argname="argument api_resource", value=api_resource, expected_type=type_hints["api_resource"])
            check_type(argname="argument api_stage", value=api_stage, expected_type=type_hints["api_stage"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if api_method is not None:
            self._values["api_method"] = api_method
        if api_resource is not None:
            self._values["api_resource"] = api_resource
        if api_stage is not None:
            self._values["api_stage"] = api_stage
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_apigateway_ceddda9d.IRestApi:
        '''(experimental) API to monitor.

        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_apigateway_ceddda9d.IRestApi, result)

    @builtins.property
    def api_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_resource(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_resource")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_stage(self) -> typing.Optional[builtins.str]:
        '''
        :default: - prod

        :stability: experimental
        '''
        result = self._values.get("api_stage")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ApiGatewayMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ApiGatewayMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param api: (experimental) API to monitor.
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - prod
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b720f596ff947157946fe1844ea9a4656c6771c11d7a5c1ad15e9f018eea59b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = ApiGatewayMonitoringProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add4_xx_error_count_alarm=add4_xx_error_count_alarm,
            add4_xx_error_rate_alarm=add4_xx_error_rate_alarm,
            add5_xx_fault_count_alarm=add5_xx_fault_count_alarm,
            add5_xx_fault_rate_alarm=add5_xx_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_average_alarm=add_latency_average_alarm,
            add_latency_p100_alarm=add_latency_p100_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p70_alarm=add_latency_p70_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p95_alarm=add_latency_p95_alarm,
            add_latency_p9999_alarm=add_latency_p9999_alarm,
            add_latency_p999_alarm=add_latency_p999_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_latency_tm50_alarm=add_latency_tm50_alarm,
            add_latency_tm70_alarm=add_latency_tm70_alarm,
            add_latency_tm90_alarm=add_latency_tm90_alarm,
            add_latency_tm95_alarm=add_latency_tm95_alarm,
            add_latency_tm95_outlier_alarm=add_latency_tm95_outlier_alarm,
            add_latency_tm9999_alarm=add_latency_tm9999_alarm,
            add_latency_tm9999_outlier_alarm=add_latency_tm9999_outlier_alarm,
            add_latency_tm999_alarm=add_latency_tm999_alarm,
            add_latency_tm999_outlier_alarm=add_latency_tm999_outlier_alarm,
            add_latency_tm99_alarm=add_latency_tm99_alarm,
            add_latency_tm99_outlier_alarm=add_latency_tm99_outlier_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            latency_types_to_render=latency_types_to_render,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efb13f07afe862abea652b153d56ecbcd1eb6c9935d1935343933ba601d331fe)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d527ebe02a354f1c53b3878152be184b23cfc45ec0f4589f60d9e26ce58c383)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0da843726b9d0590b43acae39901d875d48cdcd99c4476fdb0ef3b972ff8ffd6)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpsWidget")
    def create_tps_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cd1d3a0a2556be4a12fc62dd3dfb2b889af0a7caa8cb7983b24b058aa4450cc)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="error4XXCountMetric")
    def error4_xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4XXCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="error4XXRateMetric")
    def error4_xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4XXRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="fault5XXCountMetric")
    def fault5_xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "fault5XXCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="fault5XXRateMetric")
    def fault5_xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "fault5XXRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="latencyMetrics")
    def latency_metrics(
        self,
    ) -> typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "latencyMetrics"))

    @builtins.property
    @jsii.member(jsii_name="latencyTypesToRender")
    def latency_types_to_render(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "latencyTypesToRender"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsAlarmFactory")
    def tps_alarm_factory(self) -> TpsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TpsAlarmFactory, jsii.get(self, "tpsAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="tpsAnnotations")
    def tps_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "tpsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))


class ApiGatewayV2HttpApiMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ApiGatewayV2HttpApiMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param api: 
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - $default
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__333c3dc19812d29c6d1cdef356d6ceb57a9e346541de40c4f033ea4a082739a3)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = ApiGatewayV2HttpApiMetricFactoryProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metric4xxCount")
    def metric4xx_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4xxCount", []))

    @jsii.member(jsii_name="metric4xxRate")
    def metric4xx_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4xxRate", []))

    @jsii.member(jsii_name="metric5xxCount")
    def metric5xx_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5xxCount", []))

    @jsii.member(jsii_name="metric5xxRate")
    def metric5xx_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5xxRate", []))

    @jsii.member(jsii_name="metricIntegrationLatencyInMillis")
    def metric_integration_latency_in_millis(
        self,
        latency_type: LatencyType,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03e90424371df13e94c607f00667057762246bfc1bfdf54b3e722b4cfc5839df)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIntegrationLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricIntegrationLatencyP50InMillis")
    def metric_integration_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricIntegrationLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIntegrationLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricIntegrationLatencyP90InMillis")
    def metric_integration_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricIntegrationLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIntegrationLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricIntegrationLatencyP99InMillis")
    def metric_integration_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricIntegrationLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricIntegrationLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricInvocationCount")
    def metric_invocation_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationCount", []))

    @jsii.member(jsii_name="metricInvocationRate")
    def metric_invocation_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricInvocationRate", []))

    @jsii.member(jsii_name="metricLatencyInMillis")
    def metric_latency_in_millis(
        self,
        latency_type: LatencyType,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :param latency_type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c8b8e7278a676237b3a273a2a865d3b6efef4974a9fe40e30b2cf98a27c49217)
            check_type(argname="argument latency_type", value=latency_type, expected_type=type_hints["latency_type"])
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyInMillis", [latency_type]))

    @jsii.member(jsii_name="metricLatencyP50InMillis")
    def metric_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricLatencyP90InMillis")
    def metric_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricLatencyP99InMillis")
    def metric_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: Use {@link metricLatencyInMillis} instead.

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricTps")
    def metric_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricInvocationRate

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTps", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="fillTpsWithZeroes")
    def _fill_tps_with_zeroes(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "fillTpsWithZeroes"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayV2HttpApiMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "api": "api",
        "api_method": "apiMethod",
        "api_resource": "apiResource",
        "api_stage": "apiStage",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class ApiGatewayV2HttpApiMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param api: 
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - $default
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07a14cbee36ab23e9614418680d401aa63088f40bcfb6664ea37283c5671f2b8)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument api_method", value=api_method, expected_type=type_hints["api_method"])
            check_type(argname="argument api_resource", value=api_resource, expected_type=type_hints["api_resource"])
            check_type(argname="argument api_stage", value=api_stage, expected_type=type_hints["api_stage"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if api_method is not None:
            self._values["api_method"] = api_method
        if api_resource is not None:
            self._values["api_resource"] = api_resource
        if api_stage is not None:
            self._values["api_stage"] = api_stage
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi:
        '''
        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi, result)

    @builtins.property
    def api_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_resource(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_resource")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_stage(self) -> typing.Optional[builtins.str]:
        '''
        :default: - $default

        :stability: experimental
        '''
        result = self._values.get("api_stage")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayV2HttpApiMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ApiGatewayV2HttpApiMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ApiGatewayV2HttpApiMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param api: 
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - $default
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add4xx_count_alarm: 
        :param add4xx_rate_alarm: 
        :param add5xx_count_alarm: 
        :param add5xx_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_integration_latency_average_alarm: 
        :param add_integration_latency_p100_alarm: 
        :param add_integration_latency_p50_alarm: 
        :param add_integration_latency_p70_alarm: 
        :param add_integration_latency_p90_alarm: 
        :param add_integration_latency_p95_alarm: 
        :param add_integration_latency_p9999_alarm: 
        :param add_integration_latency_p999_alarm: 
        :param add_integration_latency_p99_alarm: 
        :param add_integration_latency_tm50_alarm: 
        :param add_integration_latency_tm70_alarm: 
        :param add_integration_latency_tm90_alarm: 
        :param add_integration_latency_tm95_alarm: 
        :param add_integration_latency_tm95_outlier_alarm: 
        :param add_integration_latency_tm9999_alarm: 
        :param add_integration_latency_tm9999_outlier_alarm: 
        :param add_integration_latency_tm999_alarm: 
        :param add_integration_latency_tm999_outlier_alarm: 
        :param add_integration_latency_tm99_alarm: 
        :param add_integration_latency_tm99_outlier_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0f379c068fa5a7227fdd5ce89fcddb3de5c2bc03d8b3d9d92525bca958a1c6d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = ApiGatewayV2HttpApiMonitoringProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add4xx_count_alarm=add4xx_count_alarm,
            add4xx_rate_alarm=add4xx_rate_alarm,
            add5xx_count_alarm=add5xx_count_alarm,
            add5xx_rate_alarm=add5xx_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_integration_latency_average_alarm=add_integration_latency_average_alarm,
            add_integration_latency_p100_alarm=add_integration_latency_p100_alarm,
            add_integration_latency_p50_alarm=add_integration_latency_p50_alarm,
            add_integration_latency_p70_alarm=add_integration_latency_p70_alarm,
            add_integration_latency_p90_alarm=add_integration_latency_p90_alarm,
            add_integration_latency_p95_alarm=add_integration_latency_p95_alarm,
            add_integration_latency_p9999_alarm=add_integration_latency_p9999_alarm,
            add_integration_latency_p999_alarm=add_integration_latency_p999_alarm,
            add_integration_latency_p99_alarm=add_integration_latency_p99_alarm,
            add_integration_latency_tm50_alarm=add_integration_latency_tm50_alarm,
            add_integration_latency_tm70_alarm=add_integration_latency_tm70_alarm,
            add_integration_latency_tm90_alarm=add_integration_latency_tm90_alarm,
            add_integration_latency_tm95_alarm=add_integration_latency_tm95_alarm,
            add_integration_latency_tm95_outlier_alarm=add_integration_latency_tm95_outlier_alarm,
            add_integration_latency_tm9999_alarm=add_integration_latency_tm9999_alarm,
            add_integration_latency_tm9999_outlier_alarm=add_integration_latency_tm9999_outlier_alarm,
            add_integration_latency_tm999_alarm=add_integration_latency_tm999_alarm,
            add_integration_latency_tm999_outlier_alarm=add_integration_latency_tm999_outlier_alarm,
            add_integration_latency_tm99_alarm=add_integration_latency_tm99_alarm,
            add_integration_latency_tm99_outlier_alarm=add_integration_latency_tm99_outlier_alarm,
            add_latency_average_alarm=add_latency_average_alarm,
            add_latency_p100_alarm=add_latency_p100_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p70_alarm=add_latency_p70_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p95_alarm=add_latency_p95_alarm,
            add_latency_p9999_alarm=add_latency_p9999_alarm,
            add_latency_p999_alarm=add_latency_p999_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_latency_tm50_alarm=add_latency_tm50_alarm,
            add_latency_tm70_alarm=add_latency_tm70_alarm,
            add_latency_tm90_alarm=add_latency_tm90_alarm,
            add_latency_tm95_alarm=add_latency_tm95_alarm,
            add_latency_tm95_outlier_alarm=add_latency_tm95_outlier_alarm,
            add_latency_tm9999_alarm=add_latency_tm9999_alarm,
            add_latency_tm9999_outlier_alarm=add_latency_tm9999_outlier_alarm,
            add_latency_tm999_alarm=add_latency_tm999_alarm,
            add_latency_tm999_outlier_alarm=add_latency_tm999_outlier_alarm,
            add_latency_tm99_alarm=add_latency_tm99_alarm,
            add_latency_tm99_outlier_alarm=add_latency_tm99_outlier_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            latency_types_to_render=latency_types_to_render,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__814dbd0e59b28a8ba31ef49112b2adf2cdc47b5782db632cc43033b145c3b72f)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6abff86504e2f01d193cd82baddbcffa8f837d7276e28e86ba014b104360577)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ceae0f5e532726995d49835b07bb976393fa7d8cdddea5e281500b59f6402f8)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpsWidget")
    def create_tps_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__674420fbad9bbb8844a16ca12cd65af8559421cd53b4ed77e34fc29b29c0ef56)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="error4xxCountMetric")
    def error4xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4xxCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="error4xxRateMetric")
    def error4xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4xxRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="error5xxCountMetric")
    def error5xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error5xxCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="error5xxRateMetric")
    def error5xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error5xxRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="integrationLatencyMetrics")
    def integration_latency_metrics(
        self,
    ) -> typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "integrationLatencyMetrics"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="latencyMetrics")
    def latency_metrics(
        self,
    ) -> typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "latencyMetrics"))

    @builtins.property
    @jsii.member(jsii_name="latencyTypesToRender")
    def latency_types_to_render(self) -> typing.List[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "latencyTypesToRender"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsAlarmFactory")
    def tps_alarm_factory(self) -> TpsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TpsAlarmFactory, jsii.get(self, "tpsAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="tpsAnnotations")
    def tps_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "tpsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))


class AppSyncMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AppSyncMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param api: (experimental) the GraphQL API to monitor.
        :param fill_tps_with_zeroes: (experimental) whether the TPS should be filled with zeroes. Default: - true
        :param rate_computation_method: (experimental) method to compute TPS. Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__844568eb480ed5add96a514f3f3406ba540b24afc110ececdddf2622cce93398)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = AppSyncMetricFactoryProps(
            api=api,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metric4XXErrorCount")
    def metric4_xx_error_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4XXErrorCount", []))

    @jsii.member(jsii_name="metric4XXErrorRate")
    def metric4_xx_error_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric4XXErrorRate", []))

    @jsii.member(jsii_name="metric5XXFaultCount")
    def metric5_xx_fault_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5XXFaultCount", []))

    @jsii.member(jsii_name="metric5XXFaultRate")
    def metric5_xx_fault_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metric5XXFaultRate", []))

    @jsii.member(jsii_name="metricLatencyP50InMillis")
    def metric_latency_p50_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP50InMillis", []))

    @jsii.member(jsii_name="metricLatencyP90InMillis")
    def metric_latency_p90_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP90InMillis", []))

    @jsii.member(jsii_name="metricLatencyP99InMillis")
    def metric_latency_p99_in_millis(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricLatencyP99InMillis", []))

    @jsii.member(jsii_name="metricRequestCount")
    def metric_request_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRequestCount", []))

    @jsii.member(jsii_name="metricRequestRate")
    def metric_request_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricRequestRate", []))

    @jsii.member(jsii_name="metricTps")
    def metric_tps(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :deprecated: use metricRequestRate

        :stability: deprecated
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricTps", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))

    @builtins.property
    @jsii.member(jsii_name="fillTpsWithZeroes")
    def _fill_tps_with_zeroes(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "fillTpsWithZeroes"))

    @builtins.property
    @jsii.member(jsii_name="rateComputationMethod")
    def _rate_computation_method(self) -> RateComputationMethod:
        '''
        :stability: experimental
        '''
        return typing.cast(RateComputationMethod, jsii.get(self, "rateComputationMethod"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AppSyncMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "api": "api",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class AppSyncMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param api: (experimental) the GraphQL API to monitor.
        :param fill_tps_with_zeroes: (experimental) whether the TPS should be filled with zeroes. Default: - true
        :param rate_computation_method: (experimental) method to compute TPS. Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a9865c80c4bcd1d83aeabfe926ada4cdd9d8bf53b72e8a30457a25aac75fc1e)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi:
        '''(experimental) the GraphQL API to monitor.

        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_appsync_ceddda9d.IGraphqlApi, result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) whether the TPS should be filled with zeroes.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''(experimental) method to compute TPS.

        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AppSyncMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AppSyncMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AppSyncMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param api: (experimental) the GraphQL API to monitor.
        :param fill_tps_with_zeroes: (experimental) whether the TPS should be filled with zeroes. Default: - true
        :param rate_computation_method: (experimental) method to compute TPS. Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1daa967362dec41e8ebe95e6b5b774e7b59c8176d05369f509ba760460778634)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = AppSyncMonitoringProps(
            add4_xx_error_count_alarm=add4_xx_error_count_alarm,
            add4_xx_error_rate_alarm=add4_xx_error_rate_alarm,
            add5_xx_fault_count_alarm=add5_xx_fault_count_alarm,
            add5_xx_fault_rate_alarm=add5_xx_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            api=api,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b724e8e62bcd6e7b334a91acc881dd5d9a9c9dc7682a69b26c4c3e9bb5ff6785)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__045ec8c570f1cfc4c02943856129d3c9cd01daf12755ed830af5070044c8b354)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e80198ad898c199cd24e611449241fa11af413007581cf50ecfdf91da799885b)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createTpsWidget")
    def create_tps_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a8208dc21f2b1b65649074b8c4b4d555f7178a39d5b3795e2160438099a3ec8)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpsWidget", [width, height]))

    @jsii.member(jsii_name="createtTitleWidget")
    def createt_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createtTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="error4xxCountMetric")
    def error4xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4xxCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="error4xxRateMetric")
    def error4xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4xxRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="fault5xxCountMetric")
    def fault5xx_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "fault5xxCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="fault5xxRateMetric")
    def fault5xx_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "fault5xxRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def metric_factory(self) -> AppSyncMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AppSyncMetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="namingStrategy")
    def naming_strategy(self) -> MonitoringNamingStrategy:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringNamingStrategy, jsii.get(self, "namingStrategy"))

    @builtins.property
    @jsii.member(jsii_name="p50LatencyMetric")
    def p50_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90LatencyMetric")
    def p90_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99LatencyMetric")
    def p99_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsAlarmFactory")
    def tps_alarm_factory(self) -> TpsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TpsAlarmFactory, jsii.get(self, "tpsAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="tpsAnnotations")
    def tps_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "tpsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))


@jsii.implements(ILoadBalancerMetricFactory)
class ApplicationLoadBalancerMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ApplicationLoadBalancerMetricFactory",
):
    '''(experimental) Metric factory to create metrics for application load-balanced service.

    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param application_load_balancer: 
        :param application_target_group: 
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb24f9c84d04f099fdf8ff84601bffb14256c8f67e7756029d0dd6553783bd4d)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = ApplicationLoadBalancerMetricFactoryProps(
            application_load_balancer=application_load_balancer,
            application_target_group=application_target_group,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricActiveConnectionCount")
    def metric_active_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricActiveConnectionCount", []))

    @jsii.member(jsii_name="metricHealthyTaskCount")
    def metric_healthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskCount", []))

    @jsii.member(jsii_name="metricHealthyTaskInPercent")
    def metric_healthy_task_in_percent(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricHealthyTaskInPercent", []))

    @jsii.member(jsii_name="metricNewConnectionCount")
    def metric_new_connection_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricNewConnectionCount", []))

    @jsii.member(jsii_name="metricProcessedBytesMin")
    def metric_processed_bytes_min(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricProcessedBytesMin", []))

    @jsii.member(jsii_name="metricUnhealthyRoutingCount")
    def metric_unhealthy_routing_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyRoutingCount", []))

    @jsii.member(jsii_name="metricUnhealthyTaskCount")
    def metric_unhealthy_task_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricUnhealthyTaskCount", []))

    @builtins.property
    @jsii.member(jsii_name="applicationLoadBalancer")
    def _application_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, jsii.get(self, "applicationLoadBalancer"))

    @builtins.property
    @jsii.member(jsii_name="applicationTargetGroup")
    def _application_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, jsii.get(self, "applicationTargetGroup"))

    @builtins.property
    @jsii.member(jsii_name="invertStatisticsOfTaskCountEnabled")
    def _invert_statistics_of_task_count_enabled(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "invertStatisticsOfTaskCountEnabled"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApplicationLoadBalancerMetricFactoryProps",
    jsii_struct_bases=[BaseLoadBalancerMetricFactoryProps, BaseMetricFactoryProps],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "application_load_balancer": "applicationLoadBalancer",
        "application_target_group": "applicationTargetGroup",
    },
)
class ApplicationLoadBalancerMetricFactoryProps(
    BaseLoadBalancerMetricFactoryProps,
    BaseMetricFactoryProps,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
    ) -> None:
        '''(experimental) Props to create ApplicationLoadBalancerMetricFactory.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param application_load_balancer: 
        :param application_target_group: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__81e225d547c4cbfc767f806ecf23670cc87eac8536e93d8d47f47b0b1935b130)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument application_load_balancer", value=application_load_balancer, expected_type=type_hints["application_load_balancer"])
            check_type(argname="argument application_target_group", value=application_target_group, expected_type=type_hints["application_target_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application_load_balancer": application_load_balancer,
            "application_target_group": application_target_group,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def application_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_load_balancer")
        assert result is not None, "Required property 'application_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, result)

    @builtins.property
    def application_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_target_group")
        assert result is not None, "Required property 'application_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApplicationLoadBalancerMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AuroraClusterMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AuroraClusterMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param add_cpu_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_serverless_database_capacity_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__827d9809fc95b8a73f5140a9e92cbdd7b7fd3c080554c6a94237a91e94a279b3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = AuroraClusterMonitoringProps(
            cluster=cluster,
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_max_serverless_database_capacity_alarm=add_max_serverless_database_capacity_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__266fcd0566054f108e9afd65962831628ec1f5fa16a14283b07760f0227cc952)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createCpuUsageWidget")
    def create_cpu_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d0bc3de6b25850b4fe616d66af593aa2dd4612468467c1aa91f4f9249e18fd7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuUsageWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a5377087ea88eadf7f740a02af832c5e9208c5bc930b74bbb42d99254da0b407)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createServerlessDatabaseCapacityWidget")
    def create_serverless_database_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29ce2f185a8fdc1d51c8d62502386d2f9066ba4ec5d979554d155b15ad38e5d7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createServerlessDatabaseCapacityWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="commitLatencyMetric")
    def commit_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "commitLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="connectionAlarmFactory")
    def connection_alarm_factory(self) -> ConnectionAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ConnectionAlarmFactory, jsii.get(self, "connectionAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="connectionAnnotations")
    def connection_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "connectionAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="deleteLatencyMetric")
    def delete_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "deleteLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="insertLatencyMetric")
    def insert_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "insertLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="selectLatencyMetric")
    def select_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "selectLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="serverlessCapacityAnnotations")
    def serverless_capacity_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "serverlessCapacityAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="serverlessDatabaseCapacityMetric")
    def serverless_database_capacity_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "serverlessDatabaseCapacityMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="updateLatencyMetric")
    def update_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "updateLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


class AutoScalingGroupMetricFactory(
    BaseMetricFactory,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AutoScalingGroupMetricFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        metric_factory: MetricFactory,
        *,
        auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param metric_factory: -
        :param auto_scaling_group: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfe1dd21cdc435fdb6501dbf50a5d3ce644af96c807d6540ef3c9b7460b7e907)
            check_type(argname="argument metric_factory", value=metric_factory, expected_type=type_hints["metric_factory"])
        props = AutoScalingGroupMetricFactoryProps(
            auto_scaling_group=auto_scaling_group, account=account, region=region
        )

        jsii.create(self.__class__, self, [metric_factory, props])

    @jsii.member(jsii_name="metricGroupDesiredCapacity")
    def metric_group_desired_capacity(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The number of instances that the Auto Scaling group attempts to maintain.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupDesiredCapacity", []))

    @jsii.member(jsii_name="metricGroupInServiceInstances")
    def metric_group_in_service_instances(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The number of instances that are running as part of the Auto Scaling group.

        This metric does not include instances that are pending or terminating.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupInServiceInstances", []))

    @jsii.member(jsii_name="metricGroupMaxSize")
    def metric_group_max_size(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The maximum size of the Auto Scaling group.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupMaxSize", []))

    @jsii.member(jsii_name="metricGroupMinSize")
    def metric_group_min_size(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The minimum size of the Auto Scaling group.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupMinSize", []))

    @jsii.member(jsii_name="metricGroupPendingInstances")
    def metric_group_pending_instances(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The number of instances that are pending.

        A pending instance is not yet in service.
        This metric does not include instances that are in service or terminating.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupPendingInstances", []))

    @jsii.member(jsii_name="metricGroupStandbyInstances")
    def metric_group_standby_instances(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The number of instances that are in a Standby state.

        Instances in this state are still running but are not actively in service.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupStandbyInstances", []))

    @jsii.member(jsii_name="metricGroupTerminatingInstances")
    def metric_group_terminating_instances(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The number of instances that are in the process of terminating.

        This metric does not include instances that are in service or pending.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupTerminatingInstances", []))

    @jsii.member(jsii_name="metricGroupTotalInstances")
    def metric_group_total_instances(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) The total number of instances in the Auto Scaling group.

        This metric identifies the number of instances that are in service, pending, and terminating.

        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "metricGroupTotalInstances", []))

    @builtins.property
    @jsii.member(jsii_name="dimensionsMap")
    def _dimensions_map(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "dimensionsMap"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AutoScalingGroupMetricFactoryProps",
    jsii_struct_bases=[BaseMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "auto_scaling_group": "autoScalingGroup",
    },
)
class AutoScalingGroupMetricFactoryProps(BaseMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param auto_scaling_group: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6de94510d05777fe13784d3f29b279afbd23e8dac87707d30b6dfc7bcd265b91)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "auto_scaling_group": auto_scaling_group,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_scaling_group(self) -> _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        assert result is not None, "Required property 'auto_scaling_group' is missing"
        return typing.cast(_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AutoScalingGroupMetricFactoryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AutoScalingGroupMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.AutoScalingGroupMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param auto_scaling_group: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dbcd9a2f4a12ab57b4d43340f7afc767f9248c9e5d6c588593e2c7e5d4078d81)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = AutoScalingGroupMonitoringProps(
            auto_scaling_group=auto_scaling_group,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createGroupSizeWidget")
    def create_group_size_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5cc9f93db7f5add5437e8783ff7785b884f5579b3a34bfe0f2f0b713976d417f)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createGroupSizeWidget", [width, height]))

    @jsii.member(jsii_name="createGroupStatusWidget")
    def create_group_status_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__55eda2fc0ab5e696fcf442f73d0962a742c77d9cb4bb79dbd34e9e40958c7fbb)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createGroupStatusWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="groupDesiredSizeMetric")
    def group_desired_size_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "groupDesiredSizeMetric"))

    @builtins.property
    @jsii.member(jsii_name="groupMaxSizeMetric")
    def group_max_size_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "groupMaxSizeMetric"))

    @builtins.property
    @jsii.member(jsii_name="groupMinSizeMetric")
    def group_min_size_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "groupMinSizeMetric"))

    @builtins.property
    @jsii.member(jsii_name="instancesInServiceMetric")
    def instances_in_service_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "instancesInServiceMetric"))

    @builtins.property
    @jsii.member(jsii_name="instancesPendingMetric")
    def instances_pending_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "instancesPendingMetric"))

    @builtins.property
    @jsii.member(jsii_name="instancesStandbyMetric")
    def instances_standby_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "instancesStandbyMetric"))

    @builtins.property
    @jsii.member(jsii_name="instancesTerminatingMetric")
    def instances_terminating_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "instancesTerminatingMetric"))

    @builtins.property
    @jsii.member(jsii_name="instancesTotalMetric")
    def instances_total_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "instancesTotalMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AvailabilityThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "min_availability_percent": "minAvailabilityPercent",
    },
)
class AvailabilityThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        min_availability_percent: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param min_availability_percent: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c47c4f9e17b67f8834271d18ac66c2e5498f510c909162acbd8ef7384251b7e6)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument min_availability_percent", value=min_availability_percent, expected_type=type_hints["min_availability_percent"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "min_availability_percent": min_availability_percent,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def min_availability_percent(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("min_availability_percent")
        assert result is not None, "Required property 'min_availability_percent' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AvailabilityThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BaseMonitoringProps",
    jsii_struct_bases=[
        BaseMetricFactoryProps, UserProvidedNames, MonitoringDashboardsOverrideProps
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class BaseMonitoringProps(
    BaseMetricFactoryProps,
    UserProvidedNames,
    MonitoringDashboardsOverrideProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''(experimental) Base class for properties passed to each monitoring construct.

        It contains (mostly optional) properties to specify naming, placement, and so on.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__303226e0420ed80925da8d7af82a367ce5ccd439752d8aaf9906e4f002b15c9b)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BillingMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.BillingMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_total_cost_anomaly_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__985ea9c05f237a4369b5828be0f4965445d030b817d4a05e8015388775a3affb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = BillingMonitoringProps(
            add_total_cost_anomaly_alarm=add_total_cost_anomaly_alarm,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createChargesByServiceWidget")
    def create_charges_by_service_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3959073f1e77b85827a201ad89dac47915a28582551e766d18229b2fb7b5c941)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createChargesByServiceWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTotalChargesWidget")
    def create_total_charges_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.SingleValueWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dff748e83a4a9ba43c4e568de12567756547489b1d24a2d2916151b7a61d133a)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.SingleValueWidget, jsii.invoke(self, "createTotalChargesWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="anomalyDetectingAlarmFactory")
    def anomaly_detecting_alarm_factory(self) -> AnomalyDetectingAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AnomalyDetectingAlarmFactory, jsii.get(self, "anomalyDetectingAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="costByServiceMetric")
    def cost_by_service_metric(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.IMetric:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric, jsii.get(self, "costByServiceMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="totalCostMetric")
    def total_cost_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "totalCostMetric"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BillingMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_total_cost_anomaly_alarm": "addTotalCostAnomalyAlarm",
    },
)
class BillingMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_total_cost_anomaly_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2752b920af7fb2759b1023d4f6b301e2bc5d38f13401be5961e1b90a3cc62d90)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_total_cost_anomaly_alarm", value=add_total_cost_anomaly_alarm, expected_type=type_hints["add_total_cost_anomaly_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_total_cost_anomaly_alarm is not None:
            self._values["add_total_cost_anomaly_alarm"] = add_total_cost_anomaly_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_total_cost_anomaly_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, AnomalyDetectionThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_total_cost_anomaly_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, AnomalyDetectionThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BillingMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.BillingMonitoringProps",
    jsii_struct_bases=[BillingMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_total_cost_anomaly_alarm": "addTotalCostAnomalyAlarm",
    },
)
class BillingMonitoringProps(BillingMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_total_cost_anomaly_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__794989ebcffbe030f2e43475b79d9492867c86ad64798762444ec6fc98262adc)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_total_cost_anomaly_alarm", value=add_total_cost_anomaly_alarm, expected_type=type_hints["add_total_cost_anomaly_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_total_cost_anomaly_alarm is not None:
            self._values["add_total_cost_anomaly_alarm"] = add_total_cost_anomaly_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_total_cost_anomaly_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, AnomalyDetectionThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_total_cost_anomaly_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, AnomalyDetectionThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BillingMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CertificateManagerMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CertificateManagerMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_days_to_expiry_alarm: 
        :param certificate: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8a717a0a53d58c17d1860989333cf65b6c91a2c20bc392e88d13f9cf17921cb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CertificateManagerMonitoringProps(
            add_days_to_expiry_alarm=add_days_to_expiry_alarm,
            certificate=certificate,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createDaysToExpiryWidget")
    def create_days_to_expiry_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__250fa9e11c63a3934ffb8d1cf29937590d3e75474c9341d04f87d26f4837e28a)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDaysToExpiryWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="daysToExpiryAnnotations")
    def days_to_expiry_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "daysToExpiryAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="daysToExpiryMetric")
    def days_to_expiry_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "daysToExpiryMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CertificateManagerMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_days_to_expiry_alarm": "addDaysToExpiryAlarm",
    },
)
class CertificateManagerMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_days_to_expiry_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c529c8080c5dd5316272113f396ef6283604a9c4773c26080229ce8c42b3ae58)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_days_to_expiry_alarm", value=add_days_to_expiry_alarm, expected_type=type_hints["add_days_to_expiry_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_days_to_expiry_alarm is not None:
            self._values["add_days_to_expiry_alarm"] = add_days_to_expiry_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_days_to_expiry_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysToExpiryThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_to_expiry_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysToExpiryThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CertificateManagerMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CertificateManagerMonitoringProps",
    jsii_struct_bases=[
        CertificateManagerMonitoringOptions, CertificateManagerMetricFactoryProps
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_days_to_expiry_alarm": "addDaysToExpiryAlarm",
        "certificate": "certificate",
    },
)
class CertificateManagerMonitoringProps(
    CertificateManagerMonitoringOptions,
    CertificateManagerMetricFactoryProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_days_to_expiry_alarm: 
        :param certificate: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6093e537fe2b41f8d4f6d88473fc4b146981d120599da6daeabb9ae01dd1bc76)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_days_to_expiry_alarm", value=add_days_to_expiry_alarm, expected_type=type_hints["add_days_to_expiry_alarm"])
            check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "certificate": certificate,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_days_to_expiry_alarm is not None:
            self._values["add_days_to_expiry_alarm"] = add_days_to_expiry_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_days_to_expiry_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysToExpiryThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_to_expiry_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysToExpiryThreshold]], result)

    @builtins.property
    def certificate(self) -> _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate:
        '''
        :stability: experimental
        '''
        result = self._values.get("certificate")
        assert result is not None, "Required property 'certificate' is missing"
        return typing.cast(_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CertificateManagerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ChangeInSecretCountThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "alarm_when_decreased": "alarmWhenDecreased",
        "alarm_when_increased": "alarmWhenIncreased",
        "required_secret_count": "requiredSecretCount",
        "additional_description": "additionalDescription",
    },
)
class ChangeInSecretCountThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        alarm_when_decreased: builtins.bool,
        alarm_when_increased: builtins.bool,
        required_secret_count: jsii.Number,
        additional_description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param alarm_when_decreased: 
        :param alarm_when_increased: 
        :param required_secret_count: 
        :param additional_description: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7ea4eb337e6e22cef130bc0fdb5254f12875a9ae1c3badfdc3e940666fdf265)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument alarm_when_decreased", value=alarm_when_decreased, expected_type=type_hints["alarm_when_decreased"])
            check_type(argname="argument alarm_when_increased", value=alarm_when_increased, expected_type=type_hints["alarm_when_increased"])
            check_type(argname="argument required_secret_count", value=required_secret_count, expected_type=type_hints["required_secret_count"])
            check_type(argname="argument additional_description", value=additional_description, expected_type=type_hints["additional_description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "alarm_when_decreased": alarm_when_decreased,
            "alarm_when_increased": alarm_when_increased,
            "required_secret_count": required_secret_count,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override
        if additional_description is not None:
            self._values["additional_description"] = additional_description

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def alarm_when_decreased(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_when_decreased")
        assert result is not None, "Required property 'alarm_when_decreased' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def alarm_when_increased(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("alarm_when_increased")
        assert result is not None, "Required property 'alarm_when_increased' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def required_secret_count(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("required_secret_count")
        assert result is not None, "Required property 'required_secret_count' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def additional_description(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("additional_description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChangeInSecretCountThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CloudFrontDistributionMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CloudFrontDistributionMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_error4xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault5xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
        additional_metrics_enabled: typing.Optional[builtins.bool] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_error4xx_rate: 
        :param add_fault5xx_rate: 
        :param add_high_tps_alarm: 
        :param add_low_tps_alarm: 
        :param distribution: 
        :param additional_metrics_enabled: (experimental) Generate dashboard charts for additional CloudFront distribution metrics. To enable additional metrics on your CloudFront distribution, see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional Default: - true
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e4a1cace39c4f29b3ffff6df734021951a5557ead750cc45dc667dc1814be4fd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CloudFrontDistributionMonitoringProps(
            add_error4xx_rate=add_error4xx_rate,
            add_fault5xx_rate=add_fault5xx_rate,
            add_high_tps_alarm=add_high_tps_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            distribution=distribution,
            additional_metrics_enabled=additional_metrics_enabled,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createCacheWidget")
    def create_cache_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3538163c09f71f41f7f3a83ca030ea3e765088f8b81d8e9a6d59bf30ce09ac2)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCacheWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e5a32df588d667549a1c706078ed3a6d566065103ce696037bf1e82e28093f3)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpsWidget")
    def create_tps_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__31bc1b110de542f42806a087ff78785a3d84609526ed25685c15a471776e2aef)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpsWidget", [width, height]))

    @jsii.member(jsii_name="createTrafficWidget")
    def create_traffic_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4635e763010715810de04942073a8f54f17e2bc47243202cfd42bc10a95aaacd)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTrafficWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="additionalMetricsEnabled")
    def additional_metrics_enabled(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "additionalMetricsEnabled"))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="downloadedBytesMetric")
    def downloaded_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "downloadedBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="error4xxRate")
    def error4xx_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error4xxRate"))

    @builtins.property
    @jsii.member(jsii_name="error5xxRate")
    def error5xx_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "error5xxRate"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="namingStrategy")
    def naming_strategy(self) -> MonitoringNamingStrategy:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringNamingStrategy, jsii.get(self, "namingStrategy"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsAlarmFactory")
    def tps_alarm_factory(self) -> TpsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TpsAlarmFactory, jsii.get(self, "tpsAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="tpsAnnotations")
    def tps_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "tpsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))

    @builtins.property
    @jsii.member(jsii_name="uploadedBytesMetric")
    def uploaded_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "uploadedBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="cacheHitRate")
    def cache_hit_rate(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "cacheHitRate"))

    @builtins.property
    @jsii.member(jsii_name="distributionUrl")
    def distribution_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "distributionUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CloudFrontDistributionMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class CloudFrontDistributionMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b443aecb88d3818b62896f301695762430be3bf642f8a6e018f6182db7f65a99)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CloudFrontDistributionMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CloudFrontDistributionMonitoringProps",
    jsii_struct_bases=[
        CloudFrontDistributionMetricFactoryProps,
        CloudFrontDistributionMonitoringOptions,
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "distribution": "distribution",
        "additional_metrics_enabled": "additionalMetricsEnabled",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_error4xx_rate": "addError4xxRate",
        "add_fault5xx_rate": "addFault5xxRate",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
    },
)
class CloudFrontDistributionMonitoringProps(
    CloudFrontDistributionMetricFactoryProps,
    CloudFrontDistributionMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
        additional_metrics_enabled: typing.Optional[builtins.bool] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_error4xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault5xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param distribution: 
        :param additional_metrics_enabled: (experimental) Generate dashboard charts for additional CloudFront distribution metrics. To enable additional metrics on your CloudFront distribution, see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional Default: - true
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_error4xx_rate: 
        :param add_fault5xx_rate: 
        :param add_high_tps_alarm: 
        :param add_low_tps_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45c74d34521086d3585e9bf5a5b44c8b96832aec2f929e658b1d414379e52243)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument distribution", value=distribution, expected_type=type_hints["distribution"])
            check_type(argname="argument additional_metrics_enabled", value=additional_metrics_enabled, expected_type=type_hints["additional_metrics_enabled"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_error4xx_rate", value=add_error4xx_rate, expected_type=type_hints["add_error4xx_rate"])
            check_type(argname="argument add_fault5xx_rate", value=add_fault5xx_rate, expected_type=type_hints["add_fault5xx_rate"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "distribution": distribution,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if additional_metrics_enabled is not None:
            self._values["additional_metrics_enabled"] = additional_metrics_enabled
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_error4xx_rate is not None:
            self._values["add_error4xx_rate"] = add_error4xx_rate
        if add_fault5xx_rate is not None:
            self._values["add_fault5xx_rate"] = add_fault5xx_rate
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def distribution(self) -> _aws_cdk_aws_cloudfront_ceddda9d.IDistribution:
        '''
        :stability: experimental
        '''
        result = self._values.get("distribution")
        assert result is not None, "Required property 'distribution' is missing"
        return typing.cast(_aws_cdk_aws_cloudfront_ceddda9d.IDistribution, result)

    @builtins.property
    def additional_metrics_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Generate dashboard charts for additional CloudFront distribution metrics.

        To enable additional metrics on your CloudFront distribution, see
        https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("additional_metrics_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_error4xx_rate(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_error4xx_rate")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_fault5xx_rate(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_fault5xx_rate")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CloudFrontDistributionMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CodeBuildProjectMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CodeBuildProjectMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param project: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_build_count_alarm: 
        :param add_failed_build_rate_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46f1966bec5615f9d2bfd95742a862ee5da4daf12ef093baae65df5553ae47c2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CodeBuildProjectMonitoringProps(
            project=project,
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_build_count_alarm=add_failed_build_count_alarm,
            add_failed_build_rate_alarm=add_failed_build_rate_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createBuildCountsWidget")
    def create_build_counts_widget(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createBuildCountsWidget", []))

    @jsii.member(jsii_name="createDurationWidget")
    def create_duration_widget(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDurationWidget", []))

    @jsii.member(jsii_name="createFailedBuildRateWidget")
    def create_failed_build_rate_widget(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createFailedBuildRateWidget", []))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="resolveProjectName")
    def _resolve_project_name(
        self,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
    ) -> typing.Optional[builtins.str]:
        '''
        :param project: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a4f043f3ddfb69c3db9e2e8fc16e723493828edb8601744953acda4dce58c05e)
            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "resolveProjectName", [project]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="buildCountMetric")
    def build_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "buildCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="durationAlarmFactory")
    def duration_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "durationAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="durationAnnotations")
    def duration_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "durationAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="durationP50InSecondsMetric")
    def duration_p50_in_seconds_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "durationP50InSecondsMetric"))

    @builtins.property
    @jsii.member(jsii_name="durationP90InSecondsMetric")
    def duration_p90_in_seconds_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "durationP90InSecondsMetric"))

    @builtins.property
    @jsii.member(jsii_name="durationP99InSecondsMetric")
    def duration_p99_in_seconds_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "durationP99InSecondsMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedBuildCountMetric")
    def failed_build_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedBuildCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedBuildRateMetric")
    def failed_build_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedBuildRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="succeededBuildCountMetric")
    def succeeded_build_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "succeededBuildCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="projectUrl")
    def project_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "projectUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CodeBuildProjectMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_build_count_alarm": "addFailedBuildCountAlarm",
        "add_failed_build_rate_alarm": "addFailedBuildRateAlarm",
    },
)
class CodeBuildProjectMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_build_count_alarm: 
        :param add_failed_build_rate_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2fd55f7b2b9c31e08c7c6691646786d3542f87367c775d8732c024373353074f)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_build_count_alarm", value=add_failed_build_count_alarm, expected_type=type_hints["add_failed_build_count_alarm"])
            check_type(argname="argument add_failed_build_rate_alarm", value=add_failed_build_rate_alarm, expected_type=type_hints["add_failed_build_rate_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_build_count_alarm is not None:
            self._values["add_failed_build_count_alarm"] = add_failed_build_count_alarm
        if add_failed_build_rate_alarm is not None:
            self._values["add_failed_build_rate_alarm"] = add_failed_build_rate_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_build_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_build_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_build_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_build_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CodeBuildProjectMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CodeBuildProjectMonitoringProps",
    jsii_struct_bases=[
        CodeBuildProjectMetricFactoryProps, CodeBuildProjectMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "project": "project",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_build_count_alarm": "addFailedBuildCountAlarm",
        "add_failed_build_rate_alarm": "addFailedBuildRateAlarm",
    },
)
class CodeBuildProjectMonitoringProps(
    CodeBuildProjectMetricFactoryProps,
    CodeBuildProjectMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''(experimental) Monitoring props for CodeBuild projects.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param project: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_build_count_alarm: 
        :param add_failed_build_rate_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e43f054c9d2d210bd968323d04aedfa07215cbe443e2eee42288175e213dd427)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_build_count_alarm", value=add_failed_build_count_alarm, expected_type=type_hints["add_failed_build_count_alarm"])
            check_type(argname="argument add_failed_build_rate_alarm", value=add_failed_build_rate_alarm, expected_type=type_hints["add_failed_build_rate_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "project": project,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_build_count_alarm is not None:
            self._values["add_failed_build_count_alarm"] = add_failed_build_count_alarm
        if add_failed_build_rate_alarm is not None:
            self._values["add_failed_build_rate_alarm"] = add_failed_build_rate_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def project(self) -> _aws_cdk_aws_codebuild_ceddda9d.IProject:
        '''
        :stability: experimental
        '''
        result = self._values.get("project")
        assert result is not None, "Required property 'project' is missing"
        return typing.cast(_aws_cdk_aws_codebuild_ceddda9d.IProject, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_build_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_build_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_build_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_build_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CodeBuildProjectMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IMetricAdjuster)
class CompositeMetricAdjuster(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CompositeMetricAdjuster",
):
    '''(experimental) Allows to apply a collection of {@link IMetricAdjuster} to a metric.

    :stability: experimental
    '''

    def __init__(self, adjusters: typing.Sequence[IMetricAdjuster]) -> None:
        '''
        :param adjusters: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9fd10824b90eddb252f36fe8d33ca71f8233426110eee5cfc51d6c232cc8a6c0)
            check_type(argname="argument adjusters", value=adjusters, expected_type=type_hints["adjusters"])
        jsii.create(self.__class__, self, [adjusters])

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, *adjusters: IMetricAdjuster) -> "CompositeMetricAdjuster":
        '''
        :param adjusters: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85a4fae865ca71e7ef4371e7f98b9831bb5f55e9f840da1e2dd730d9085bbf83)
            check_type(argname="argument adjusters", value=adjusters, expected_type=typing.Tuple[type_hints["adjusters"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast("CompositeMetricAdjuster", jsii.sinvoke(cls, "of", [*adjusters]))

    @jsii.member(jsii_name="adjustMetric")
    def adjust_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        alarm_scope: _constructs_77d1e7e8.Construct,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adjusts a metric.

        :param metric: -
        :param alarm_scope: -
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        :inheritdoc: true
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48e87691740111817f57dd8be791059a5947a45df5e0f3bc8af5ba949d2a542e)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument alarm_scope", value=alarm_scope, expected_type=type_hints["alarm_scope"])
        props = AddAlarmProps(
            alarm_description=alarm_description,
            alarm_name_suffix=alarm_name_suffix,
            comparison_operator=comparison_operator,
            threshold=threshold,
            treat_missing_data=treat_missing_data,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
        )

        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adjustMetric", [metric, alarm_scope, props]))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ConsumedCapacityThreshold",
    jsii_struct_bases=[CustomAlarmThreshold],
    name_mapping={
        "action_override": "actionOverride",
        "actions_enabled": "actionsEnabled",
        "alarm_description_override": "alarmDescriptionOverride",
        "alarm_name_override": "alarmNameOverride",
        "comparison_operator_override": "comparisonOperatorOverride",
        "custom_params": "customParams",
        "custom_tags": "customTags",
        "datapoints_to_alarm": "datapointsToAlarm",
        "dedupe_string_override": "dedupeStringOverride",
        "documentation_link": "documentationLink",
        "evaluate_low_sample_count_percentile": "evaluateLowSampleCountPercentile",
        "evaluation_periods": "evaluationPeriods",
        "fill_alarm_range": "fillAlarmRange",
        "metric_adjuster": "metricAdjuster",
        "min_metric_samples_to_alarm": "minMetricSamplesToAlarm",
        "min_sample_count_to_evaluate_datapoint": "minSampleCountToEvaluateDatapoint",
        "override_annotation_color": "overrideAnnotationColor",
        "override_annotation_label": "overrideAnnotationLabel",
        "override_annotation_visibility": "overrideAnnotationVisibility",
        "period": "period",
        "runbook_link": "runbookLink",
        "sample_count_metric_id": "sampleCountMetricId",
        "treat_missing_data_override": "treatMissingDataOverride",
        "max_consumed_capacity_units": "maxConsumedCapacityUnits",
    },
)
class ConsumedCapacityThreshold(CustomAlarmThreshold):
    def __init__(
        self,
        *,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
        treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
        max_consumed_capacity_units: jsii.Number,
    ) -> None:
        '''
        :param action_override: (experimental) Allows to override the default alarm action. Default: - undefined (default action will be used, if any)
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param comparison_operator_override: (experimental) Comparison operator used to compare actual value against the threshold. Default: - alarm-specific default
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state. Default: - the same as monitoring facade default
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - the same as monitoring facade default
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, a composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.
        :param treat_missing_data_override: (experimental) Behaviour in case the metric data is missing. Default: - alarm-specific default
        :param max_consumed_capacity_units: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__950df7879b973387d492483d4d3727cc319ff16796edff3c18145fac0afe46b0)
            check_type(argname="argument action_override", value=action_override, expected_type=type_hints["action_override"])
            check_type(argname="argument actions_enabled", value=actions_enabled, expected_type=type_hints["actions_enabled"])
            check_type(argname="argument alarm_description_override", value=alarm_description_override, expected_type=type_hints["alarm_description_override"])
            check_type(argname="argument alarm_name_override", value=alarm_name_override, expected_type=type_hints["alarm_name_override"])
            check_type(argname="argument comparison_operator_override", value=comparison_operator_override, expected_type=type_hints["comparison_operator_override"])
            check_type(argname="argument custom_params", value=custom_params, expected_type=type_hints["custom_params"])
            check_type(argname="argument custom_tags", value=custom_tags, expected_type=type_hints["custom_tags"])
            check_type(argname="argument datapoints_to_alarm", value=datapoints_to_alarm, expected_type=type_hints["datapoints_to_alarm"])
            check_type(argname="argument dedupe_string_override", value=dedupe_string_override, expected_type=type_hints["dedupe_string_override"])
            check_type(argname="argument documentation_link", value=documentation_link, expected_type=type_hints["documentation_link"])
            check_type(argname="argument evaluate_low_sample_count_percentile", value=evaluate_low_sample_count_percentile, expected_type=type_hints["evaluate_low_sample_count_percentile"])
            check_type(argname="argument evaluation_periods", value=evaluation_periods, expected_type=type_hints["evaluation_periods"])
            check_type(argname="argument fill_alarm_range", value=fill_alarm_range, expected_type=type_hints["fill_alarm_range"])
            check_type(argname="argument metric_adjuster", value=metric_adjuster, expected_type=type_hints["metric_adjuster"])
            check_type(argname="argument min_metric_samples_to_alarm", value=min_metric_samples_to_alarm, expected_type=type_hints["min_metric_samples_to_alarm"])
            check_type(argname="argument min_sample_count_to_evaluate_datapoint", value=min_sample_count_to_evaluate_datapoint, expected_type=type_hints["min_sample_count_to_evaluate_datapoint"])
            check_type(argname="argument override_annotation_color", value=override_annotation_color, expected_type=type_hints["override_annotation_color"])
            check_type(argname="argument override_annotation_label", value=override_annotation_label, expected_type=type_hints["override_annotation_label"])
            check_type(argname="argument override_annotation_visibility", value=override_annotation_visibility, expected_type=type_hints["override_annotation_visibility"])
            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
            check_type(argname="argument runbook_link", value=runbook_link, expected_type=type_hints["runbook_link"])
            check_type(argname="argument sample_count_metric_id", value=sample_count_metric_id, expected_type=type_hints["sample_count_metric_id"])
            check_type(argname="argument treat_missing_data_override", value=treat_missing_data_override, expected_type=type_hints["treat_missing_data_override"])
            check_type(argname="argument max_consumed_capacity_units", value=max_consumed_capacity_units, expected_type=type_hints["max_consumed_capacity_units"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "max_consumed_capacity_units": max_consumed_capacity_units,
        }
        if action_override is not None:
            self._values["action_override"] = action_override
        if actions_enabled is not None:
            self._values["actions_enabled"] = actions_enabled
        if alarm_description_override is not None:
            self._values["alarm_description_override"] = alarm_description_override
        if alarm_name_override is not None:
            self._values["alarm_name_override"] = alarm_name_override
        if comparison_operator_override is not None:
            self._values["comparison_operator_override"] = comparison_operator_override
        if custom_params is not None:
            self._values["custom_params"] = custom_params
        if custom_tags is not None:
            self._values["custom_tags"] = custom_tags
        if datapoints_to_alarm is not None:
            self._values["datapoints_to_alarm"] = datapoints_to_alarm
        if dedupe_string_override is not None:
            self._values["dedupe_string_override"] = dedupe_string_override
        if documentation_link is not None:
            self._values["documentation_link"] = documentation_link
        if evaluate_low_sample_count_percentile is not None:
            self._values["evaluate_low_sample_count_percentile"] = evaluate_low_sample_count_percentile
        if evaluation_periods is not None:
            self._values["evaluation_periods"] = evaluation_periods
        if fill_alarm_range is not None:
            self._values["fill_alarm_range"] = fill_alarm_range
        if metric_adjuster is not None:
            self._values["metric_adjuster"] = metric_adjuster
        if min_metric_samples_to_alarm is not None:
            self._values["min_metric_samples_to_alarm"] = min_metric_samples_to_alarm
        if min_sample_count_to_evaluate_datapoint is not None:
            self._values["min_sample_count_to_evaluate_datapoint"] = min_sample_count_to_evaluate_datapoint
        if override_annotation_color is not None:
            self._values["override_annotation_color"] = override_annotation_color
        if override_annotation_label is not None:
            self._values["override_annotation_label"] = override_annotation_label
        if override_annotation_visibility is not None:
            self._values["override_annotation_visibility"] = override_annotation_visibility
        if period is not None:
            self._values["period"] = period
        if runbook_link is not None:
            self._values["runbook_link"] = runbook_link
        if sample_count_metric_id is not None:
            self._values["sample_count_metric_id"] = sample_count_metric_id
        if treat_missing_data_override is not None:
            self._values["treat_missing_data_override"] = treat_missing_data_override

    @builtins.property
    def action_override(self) -> typing.Optional[IAlarmActionStrategy]:
        '''(experimental) Allows to override the default alarm action.

        :default: - undefined (default action will be used, if any)

        :stability: experimental
        '''
        result = self._values.get("action_override")
        return typing.cast(typing.Optional[IAlarmActionStrategy], result)

    @builtins.property
    def actions_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enables the configured CloudWatch alarm ticketing actions.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("actions_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def alarm_description_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) A text included in the generated ticket description body, which fully replaces the generated text.

        :default: - default auto-generated content only

        :stability: experimental
        '''
        result = self._values.get("alarm_description_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_name_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm name is set to this exact value.

        Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :stability: experimental
        '''
        result = self._values.get("alarm_name_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def comparison_operator_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator]:
        '''(experimental) Comparison operator used to compare actual value against the threshold.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("comparison_operator_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator], result)

    @builtins.property
    def custom_params(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no parameters

        :stability: experimental
        '''
        result = self._values.get("custom_params")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    @builtins.property
    def custom_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method.

        :default: - no tags

        :stability: experimental
        '''
        result = self._values.get("custom_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def datapoints_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of breaches required to transition into an ALARM state.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("datapoints_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def dedupe_string_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the alarm dedupe string is set to this exact value.

        Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually.

        :default: - undefined (no override)

        :stability: experimental
        '''
        result = self._values.get("dedupe_string_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def documentation_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("documentation_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def evaluate_low_sample_count_percentile(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Used only for alarms based on percentiles.

        If you specify false, the alarm state does not change during periods with too few data points to be statistically significant.
        If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("evaluate_low_sample_count_percentile")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def evaluation_periods(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of periods to consider when checking the number of breaching datapoints.

        :default: - the same as monitoring facade default

        :stability: experimental
        '''
        result = self._values.get("evaluation_periods")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fill_alarm_range(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the alarming range of values should be highlighted in the widget.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("fill_alarm_range")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def metric_adjuster(self) -> typing.Optional[IMetricAdjuster]:
        '''(experimental) If specified, adjusts the metric before creating an alarm from it.

        :default: - no adjuster

        :stability: experimental
        '''
        result = self._values.get("metric_adjuster")
        return typing.cast(typing.Optional[IMetricAdjuster], result)

    @builtins.property
    def min_metric_samples_to_alarm(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm.

        If this property is specified, a composite alarm is created of the following:

        :default: - default behaviour - no condition on sample count will be added to the alarm

        :deprecated:

        Use minSampleCountToEvaluateDatapoint instead. minMetricSamplesAlarm uses different evaluation
        period for its child alarms, so it doesn't guarantee that each datapoint in the evaluation period has
        sufficient number of samples

        :stability: deprecated
        '''
        result = self._values.get("min_metric_samples_to_alarm")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_sample_count_to_evaluate_datapoint(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming.

        If this property is specified, your metric will be subject to MathExpression that will add an IF condition
        to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples.
        If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated
        according to the treatMissingData parameter.
        If specified, deprecated minMetricSamplesToAlarm has no effect.

        :default: - default behaviour - no condition on sample count will be used

        :stability: experimental
        '''
        result = self._values.get("min_sample_count_to_evaluate_datapoint")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def override_annotation_color(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation color.

        :default: - no override (default color)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_color")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_label(self) -> typing.Optional[builtins.str]:
        '''(experimental) If specified, it modifies the final alarm annotation label.

        :default: - no override (default label)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_label")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def override_annotation_visibility(self) -> typing.Optional[builtins.bool]:
        '''(experimental) If specified, it modifies the final alarm annotation visibility.

        :default: - no override (default visibility)

        :stability: experimental
        '''
        result = self._values.get("override_annotation_visibility")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def period(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) Period override for the metric to alarm on.

        :default: - the default specified in MetricFactory

        :stability: experimental
        '''
        result = self._values.get("period")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    @builtins.property
    def runbook_link(self) -> typing.Optional[builtins.str]:
        '''(experimental) An optional link included in the generated ticket description body.

        :default: - no additional link will be added

        :stability: experimental
        '''
        result = self._values.get("runbook_link")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sample_count_metric_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) This property is required in the following situation:       minSampleCountToEvaluateDatapoint is specified      the metric used for the alarm is a MathExpression      the MathExpression is composed of more than one metric .

        In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics
        property that should be used as the sampleCount metric for the new MathExpression as described in the documentation
        for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        '''
        result = self._values.get("sample_count_metric_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def treat_missing_data_override(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData]:
        '''(experimental) Behaviour in case the metric data is missing.

        :default: - alarm-specific default

        :stability: experimental
        '''
        result = self._values.get("treat_missing_data_override")
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData], result)

    @builtins.property
    def max_consumed_capacity_units(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_consumed_capacity_units")
        assert result is not None, "Required property 'max_consumed_capacity_units' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ConsumedCapacityThreshold(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomEc2ServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseEc2ServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "ec2_service": "ec2Service",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
        "load_balancer": "loadBalancer",
        "target_group": "targetGroup",
    },
)
class CustomEc2ServiceMonitoringProps(BaseMonitoringProps, BaseEc2ServiceAlarms):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
        target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param load_balancer: 
        :param target_group: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a304626361860e6052d9dfb4a3f62116e2ded9276e6660ec72b9b9b60e5e0abb)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
            check_type(argname="argument load_balancer", value=load_balancer, expected_type=type_hints["load_balancer"])
            check_type(argname="argument target_group", value=target_group, expected_type=type_hints["target_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ec2_service": ec2_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics
        if load_balancer is not None:
            self._values["load_balancer"] = load_balancer
        if target_group is not None:
            self._values["target_group"] = target_group

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ec2_service(self) -> _aws_cdk_aws_ecs_ceddda9d.IBaseService:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.IBaseService, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def load_balancer(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("load_balancer")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]], result)

    @builtins.property
    def target_group(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("target_group")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomEc2ServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomFargateServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseFargateServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "fargate_service": "fargateService",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
        "load_balancer": "loadBalancer",
        "target_group": "targetGroup",
    },
)
class CustomFargateServiceMonitoringProps(
    BaseMonitoringProps,
    BaseFargateServiceAlarms,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
        target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param load_balancer: 
        :param target_group: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca148996f7cf647fe69caf41a893806d1dde924d66daedd882dbf8ad4004aaa4)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
            check_type(argname="argument load_balancer", value=load_balancer, expected_type=type_hints["load_balancer"])
            check_type(argname="argument target_group", value=target_group, expected_type=type_hints["target_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "fargate_service": fargate_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics
        if load_balancer is not None:
            self._values["load_balancer"] = load_balancer
        if target_group is not None:
            self._values["target_group"] = target_group

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fargate_service(self) -> _aws_cdk_aws_ecs_ceddda9d.IBaseService:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.IBaseService, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def load_balancer(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("load_balancer")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]], result)

    @builtins.property
    def target_group(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("target_group")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomFargateServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CustomMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.CustomMonitoring",
):
    '''(experimental) Custom monitoring is a construct allowing you to monitor your own custom metrics.

    The entire construct consists of metric groups.
    Each metric group represents a single graph widget with multiple metrics.
    Each metric inside the metric group represents a single metric inside a graph.
    The widgets will be sized automatically to waste as little space as possible.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        metric_groups: typing.Sequence[typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]]],
        description: typing.Optional[builtins.str] = None,
        description_widget_height: typing.Optional[jsii.Number] = None,
        height: typing.Optional[jsii.Number] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param metric_groups: (experimental) define metric groups and metrics inside them (each metric group represents a widget).
        :param description: (experimental) optional description of the whole section, in markdown. Default: - no description
        :param description_widget_height: (experimental) optional height of the description widget, so the content fits. Default: - minimum height (should fit one or two lines of text)
        :param height: (experimental) Height override. Default: - default height
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb6901613ed4d317d1376c856406d320c178d064742c7c03d53ae434d9a53a80)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CustomMonitoringProps(
            metric_groups=metric_groups,
            description=description,
            description_widget_height=description_widget_height,
            height=height,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="addToSummaryDashboard")
    def add_to_summary_dashboard(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "addToSummaryDashboard"))

    @builtins.property
    @jsii.member(jsii_name="anomalyDetectingAlarmFactory")
    def anomaly_detecting_alarm_factory(self) -> AnomalyDetectingAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AnomalyDetectingAlarmFactory, jsii.get(self, "anomalyDetectingAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="customAlarmFactory")
    def custom_alarm_factory(self) -> CustomAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(CustomAlarmFactory, jsii.get(self, "customAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="metricGroups")
    def metric_groups(self) -> typing.List[CustomMetricGroupWithAnnotations]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[CustomMetricGroupWithAnnotations], jsii.get(self, "metricGroups"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="descriptionWidgetHeight")
    def description_widget_height(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "descriptionWidgetHeight"))

    @builtins.property
    @jsii.member(jsii_name="height")
    def height(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "height"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.CustomMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "metric_groups": "metricGroups",
        "description": "description",
        "description_widget_height": "descriptionWidgetHeight",
        "height": "height",
    },
)
class CustomMonitoringProps(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        metric_groups: typing.Sequence[typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]]],
        description: typing.Optional[builtins.str] = None,
        description_widget_height: typing.Optional[jsii.Number] = None,
        height: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param metric_groups: (experimental) define metric groups and metrics inside them (each metric group represents a widget).
        :param description: (experimental) optional description of the whole section, in markdown. Default: - no description
        :param description_widget_height: (experimental) optional height of the description widget, so the content fits. Default: - minimum height (should fit one or two lines of text)
        :param height: (experimental) Height override. Default: - default height

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34981c330536725daac1b224ffb995800483868db8f6c76aee1c38ee2dbac848)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument metric_groups", value=metric_groups, expected_type=type_hints["metric_groups"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument description_widget_height", value=description_widget_height, expected_type=type_hints["description_widget_height"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "metric_groups": metric_groups,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if description is not None:
            self._values["description"] = description
        if description_widget_height is not None:
            self._values["description_widget_height"] = description_widget_height
        if height is not None:
            self._values["height"] = height

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def metric_groups(self) -> typing.List[CustomMetricGroup]:
        '''(experimental) define metric groups and metrics inside them (each metric group represents a widget).

        :stability: experimental
        '''
        result = self._values.get("metric_groups")
        assert result is not None, "Required property 'metric_groups' is missing"
        return typing.cast(typing.List[CustomMetricGroup], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) optional description of the whole section, in markdown.

        :default: - no description

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description_widget_height(self) -> typing.Optional[jsii.Number]:
        '''(experimental) optional height of the description widget, so the content fits.

        :default: - minimum height (should fit one or two lines of text)

        :stability: experimental
        '''
        result = self._values.get("description_widget_height")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def height(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Height override.

        :default: - default height

        :stability: experimental
        '''
        result = self._values.get("height")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IDashboardFactory, IDynamicDashboardFactory)
class DefaultDashboardFactory(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DefaultDashboardFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        dashboard_name_prefix: builtins.str,
        create_alarm_dashboard: typing.Optional[builtins.bool] = None,
        create_dashboard: typing.Optional[builtins.bool] = None,
        create_summary_dashboard: typing.Optional[builtins.bool] = None,
        detail_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        detail_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
        summary_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        summary_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param dashboard_name_prefix: (experimental) Prefix added to each dashboard name. This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.
        :param create_alarm_dashboard: (experimental) Flag indicating whether the alarm dashboard should be created. This is independent on other create dashboard flags. Default: - false
        :param create_dashboard: (experimental) Flag indicating whether the default dashboard should be created. This is independent on other create dashboard flags. Default: - true
        :param create_summary_dashboard: (experimental) Flag indicating whether the summary dashboard should be created. This is independent on other create dashboard flags. Default: - false
        :param detail_dashboard_period_override: (experimental) Period override for the detail dashboard (and other auxiliary dashboards). Default: - respect individual graphs (PeriodOverride.INHERIT)
        :param detail_dashboard_range: (experimental) Range of the detail dashboard (and other auxiliary dashboards). Default: - 8 hours
        :param rendering_preference: (experimental) Dashboard rendering preference. Default: - DashboardRenderingPreference.INTERACTIVE_ONLY
        :param summary_dashboard_period_override: (experimental) Period override for the summary dashboard. Default: - respect individual graphs (PeriodOverride.INHERIT)
        :param summary_dashboard_range: (experimental) Range of the summary dashboard. Default: - 14 days

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a7da71f0777f8bc55169f8588a8908fe7713005945fa342531e6ca22b135857)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = MonitoringDashboardsProps(
            dashboard_name_prefix=dashboard_name_prefix,
            create_alarm_dashboard=create_alarm_dashboard,
            create_dashboard=create_dashboard,
            create_summary_dashboard=create_summary_dashboard,
            detail_dashboard_period_override=detail_dashboard_period_override,
            detail_dashboard_range=detail_dashboard_range,
            rendering_preference=rendering_preference,
            summary_dashboard_period_override=summary_dashboard_period_override,
            summary_dashboard_range=summary_dashboard_range,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addDynamicSegment")
    def add_dynamic_segment(self, segment: IDynamicDashboardSegment) -> None:
        '''(experimental) Adds a dynamic dashboard segment.

        :param segment: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__567a33262c9610e38349af9ccacb33edf7e26b136711f9a102f2c15da7bd701b)
            check_type(argname="argument segment", value=segment, expected_type=type_hints["segment"])
        return typing.cast(None, jsii.invoke(self, "addDynamicSegment", [segment]))

    @jsii.member(jsii_name="addSegment")
    def add_segment(self, props: IDashboardFactoryProps) -> None:
        '''
        :param props: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ce41a9d218dc88cc03af8fff60a47c505172785362dfde6b048ab496df577ab)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(None, jsii.invoke(self, "addSegment", [props]))

    @jsii.member(jsii_name="createdAlarmDashboard")
    def created_alarm_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdAlarmDashboard", []))

    @jsii.member(jsii_name="createDashboard")
    def _create_dashboard(
        self,
        rendering_preference: DashboardRenderingPreference,
        id: builtins.str,
        *,
        dashboard_name: typing.Optional[builtins.str] = None,
        default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        end: typing.Optional[builtins.str] = None,
        period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        start: typing.Optional[builtins.str] = None,
        variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
        widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard:
        '''
        :param rendering_preference: -
        :param id: -
        :param dashboard_name: Name of the dashboard. If set, must only contain alphanumerics, dash (-) and underscore (_) Default: - automatically generated name
        :param default_interval: Interval duration for metrics. You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)). Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the defaultInterval time will be the default time range.
        :param end: The end of the time range to use for each widget on the dashboard when the dashboard loads. If you specify a value for end, you must also specify a value for start. Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Default: When the dashboard loads, the end date will be the current time.
        :param period_override: Use this field to specify the period for the graphs when the dashboard loads. Specifying ``Auto`` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard. Specifying ``Inherit`` ensures that the period set for each graph is always obeyed. Default: Auto
        :param start: The start of the time range to use for each widget on the dashboard. You can specify start without specifying end to specify a relative time range that ends with the current time. In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months. You can also use start along with an end field, to specify an absolute time range. When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the start time will be the default time range.
        :param variables: A list of dashboard variables. Default: - No variables
        :param widgets: Initial set of widgets on the dashboard. One array represents a row of widgets. Default: - No widgets

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e62bb0f28f588b4411f45a58716e45012b165bcbfef46d9e8dc4d08e4128f1da)
            check_type(argname="argument rendering_preference", value=rendering_preference, expected_type=type_hints["rendering_preference"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.DashboardProps(
            dashboard_name=dashboard_name,
            default_interval=default_interval,
            end=end,
            period_override=period_override,
            start=start,
            variables=variables,
            widgets=widgets,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard, jsii.invoke(self, "createDashboard", [rendering_preference, id, props]))

    @jsii.member(jsii_name="createdDashboard")
    def created_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdDashboard", []))

    @jsii.member(jsii_name="createdSummaryDashboard")
    def created_summary_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdSummaryDashboard", []))

    @jsii.member(jsii_name="getDashboard")
    def get_dashboard(
        self,
        name: builtins.str,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''(experimental) Gets the dashboard for the requested dashboard type.

        :param name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__24cf41e334fc53d3f876a745193eb55210100ca2f5334512e60d698413149183)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "getDashboard", [name]))

    @builtins.property
    @jsii.member(jsii_name="anyDashboardCreated")
    def any_dashboard_created(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "anyDashboardCreated"))

    @builtins.property
    @jsii.member(jsii_name="dashboards")
    def dashboards(
        self,
    ) -> typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.get(self, "dashboards"))

    @builtins.property
    @jsii.member(jsii_name="alarmDashboard")
    def alarm_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.get(self, "alarmDashboard"))

    @builtins.property
    @jsii.member(jsii_name="dashboard")
    def dashboard(self) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.get(self, "dashboard"))

    @builtins.property
    @jsii.member(jsii_name="summaryDashboard")
    def summary_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.get(self, "summaryDashboard"))


@jsii.implements(IMetricAdjuster)
class DefaultMetricAdjuster(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DefaultMetricAdjuster",
):
    '''(experimental) Applies the default metric adjustments.

    These adjustments are always applied last, regardless the value configured in {@link AddAlarmProps.metricAdjuster}.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="adjustMetric")
    def adjust_metric(
        self,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        _: _constructs_77d1e7e8.Construct,
        *,
        alarm_description: builtins.str,
        alarm_name_suffix: builtins.str,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        threshold: jsii.Number,
        treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        datapoints_to_alarm: typing.Optional[jsii.Number] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
        evaluation_periods: typing.Optional[jsii.Number] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        metric_adjuster: typing.Optional[IMetricAdjuster] = None,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        runbook_link: typing.Optional[builtins.str] = None,
        sample_count_metric_id: typing.Optional[builtins.str] = None,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''(experimental) Adjusts a metric.

        :param metric: -
        :param _: -
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique.
        :param comparison_operator: (experimental) Comparison operator used to compare actual value against the threshold.
        :param threshold: (experimental) Threshold to alarm on.
        :param treat_missing_data: (experimental) Behaviour in case the metric data is missing.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and regions (EU, NA...) manually.
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param datapoints_to_alarm: (experimental) Number of breaches required to transition into an ALARM state.
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and regions (EU, NA...) manually. Default: - undefined (no override)
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones. Default: - undefined (no disambiguator)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param evaluate_low_sample_count_percentile: (experimental) Used only for alarms based on percentiles. If you specify false, the alarm state does not change during periods with too few data points to be statistically significant. If you specify true, the alarm is always evaluated and possibly changes state no matter how many data points are available. Default: - true
        :param evaluation_periods: (experimental) Number of periods to consider when checking the number of breaching datapoints. Default: - Same as datapointsToAlarm.
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param metric_adjuster: (experimental) If specified, adjusts the metric before creating an alarm from it. Default: - no adjuster
        :param min_metric_samples_to_alarm: (deprecated) Specifies how many samples (N) of the metric is needed to trigger the alarm. If this property is specified, an artificial composite alarm is created of the following: Default: - default behaviour - no condition on sample count will be added to the alarm
        :param min_sample_count_to_evaluate_datapoint: (experimental) Specifies how many samples (N) of the metric is needed in a datapoint to be evaluated for alarming. If this property is specified, your metric will be subject to MathExpression that will add an IF condition to your metric to make sure that each datapoint is evaluated only if it has sufficient number of samples. If the number of samples is not sufficient, the datapoint will be treated as missing data and will be evaluated according to the treatMissingData parameter. If specified, deprecated minMetricSamplesToAlarm has no effect. Default: - default behaviour - no condition on sample count will be used
        :param override_annotation_color: (experimental) If specified, it modifies the final alarm annotation color. Default: - no override (default color)
        :param override_annotation_label: (experimental) If specified, it modifies the final alarm annotation label. Default: - no override (default label)
        :param override_annotation_visibility: (experimental) If specified, it modifies the final alarm annotation visibility. Default: - no override (default visibility)
        :param period: (experimental) Period override for the metric to alarm on. Default: - the default specified in MetricFactory
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param sample_count_metric_id: (experimental) This property is required in the following situation: minSampleCountToEvaluateDatapoint is specified the metric used for the alarm is a MathExpression the MathExpression is composed of more than one metric . In this situation, this property indicates the metric Id in the MathExpression’s usingMetrics property that should be used as the sampleCount metric for the new MathExpression as described in the documentation for minSampleCountToEvaluateDatapoint.

        :stability: experimental
        :inheritdoc: true
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c48f2a5fd9c390758999ac1b50190054bbfe7413aaeeeb8f2645d38242ecbeb3)
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument _", value=_, expected_type=type_hints["_"])
        props = AddAlarmProps(
            alarm_description=alarm_description,
            alarm_name_suffix=alarm_name_suffix,
            comparison_operator=comparison_operator,
            threshold=threshold,
            treat_missing_data=treat_missing_data,
            action_override=action_override,
            actions_enabled=actions_enabled,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            custom_params=custom_params,
            custom_tags=custom_tags,
            datapoints_to_alarm=datapoints_to_alarm,
            dedupe_string_override=dedupe_string_override,
            disambiguator=disambiguator,
            documentation_link=documentation_link,
            evaluate_low_sample_count_percentile=evaluate_low_sample_count_percentile,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric_adjuster=metric_adjuster,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            period=period,
            runbook_link=runbook_link,
            sample_count_metric_id=sample_count_metric_id,
        )

        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.invoke(self, "adjustMetric", [metric, _, props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="INSTANCE")
    def INSTANCE(cls) -> "DefaultMetricAdjuster":
        '''
        :stability: experimental
        '''
        return typing.cast("DefaultMetricAdjuster", jsii.sget(cls, "INSTANCE"))


@jsii.implements(IWidgetFactory)
class DefaultWidgetFactory(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DefaultWidgetFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="createAlarmDetailWidget")
    def create_alarm_detail_widget(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
        alarm_description: builtins.str,
        alarm_label: builtins.str,
        alarm_name: builtins.str,
        alarm_name_suffix: builtins.str,
        alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
        annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IWidget:
        '''(experimental) Create widget representing an alarm detail.

        :param alarm: 
        :param alarm_description: 
        :param alarm_label: 
        :param alarm_name: 
        :param alarm_name_suffix: 
        :param alarm_rule_when_alarming: 
        :param alarm_rule_when_insufficient_data: 
        :param alarm_rule_when_ok: 
        :param annotation: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        alarm_ = AlarmWithAnnotation(
            alarm=alarm,
            alarm_description=alarm_description,
            alarm_label=alarm_label,
            alarm_name=alarm_name,
            alarm_name_suffix=alarm_name_suffix,
            alarm_rule_when_alarming=alarm_rule_when_alarming,
            alarm_rule_when_insufficient_data=alarm_rule_when_insufficient_data,
            alarm_rule_when_ok=alarm_rule_when_ok,
            annotation=annotation,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IWidget, jsii.invoke(self, "createAlarmDetailWidget", [alarm_]))


class DocumentDbMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DocumentDbMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param cluster: (experimental) database cluster.
        :param add_cpu_usage_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1e88e4f36ea1e7b66a8daefacf2fb97dc7886edecbe71599c6c6c8eee077021)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = DocumentDbMonitoringProps(
            cluster=cluster,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98acd3af858124086fbf09683321a61ffb023b09963e2b84fc5a1a98b76bf006)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6060f9240007102ddcfefb66091157ccbbb11b7bec5e93f4507a2d4e01651f8)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createResourceUsageWidget")
    def create_resource_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7b858d160ab88e517ff5eed0af5b6a55fa19eae6a3e5e4d80530d09aaf7cfdb7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createResourceUsageWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTransactionsWidget")
    def create_transactions_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b654642762c1748e55f5171b47b089c3b2bed62fe06c7082929bb45f87af460)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTransactionsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="cursorsMetric")
    def cursors_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cursorsMetric"))

    @builtins.property
    @jsii.member(jsii_name="readLatencyMetric")
    def read_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="throttledMetric")
    def throttled_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "throttledMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="transactionsMetric")
    def transactions_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "transactionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="writeLatencyMetric")
    def write_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "url"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DocumentDbMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
    },
)
class DocumentDbMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7c52457e6fd71c3f03a296fc85591a202914a350f19b63930e9042b2cbc90132)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DocumentDbMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DocumentDbMonitoringProps",
    jsii_struct_bases=[DocumentDbMetricFactoryProps, DocumentDbMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster": "cluster",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
    },
)
class DocumentDbMonitoringProps(
    DocumentDbMetricFactoryProps,
    DocumentDbMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster: (experimental) database cluster.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b24b5c45366956ac2a02dc6668886aa14a662de443690fd1b7f5b43e84c2ef83)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster": cluster,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster(self) -> _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster:
        '''(experimental) database cluster.

        :stability: experimental
        '''
        result = self._values.get("cluster")
        assert result is not None, "Required property 'cluster' is missing"
        return typing.cast(_aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DocumentDbMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IDynamicDashboardFactory)
class DynamicDashboardFactory(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamicDashboardFactory",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        dashboard_configs: typing.Sequence[typing.Union[DynamicDashboardConfiguration, typing.Dict[builtins.str, typing.Any]]],
        dashboard_name_prefix: builtins.str,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param dashboard_configs: (experimental) List of dashboard types to generate.
        :param dashboard_name_prefix: (experimental) Prefix added to each dashboard's name. This allows to have all dashboards sorted close to each other and also separate multiple monitoring facades.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b500f3cc5c40638ab2379baaea64735ddc3f97a08ee1e394580c5a07f6abd325)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = MonitoringDynamicDashboardsProps(
            dashboard_configs=dashboard_configs,
            dashboard_name_prefix=dashboard_name_prefix,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addDynamicSegment")
    def add_dynamic_segment(self, segment: IDynamicDashboardSegment) -> None:
        '''(experimental) Adds a dynamic dashboard segment.

        :param segment: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48317c1c565aba9d39738b52c4a7783f0731f90098223c6811b332d68caaa03b)
            check_type(argname="argument segment", value=segment, expected_type=type_hints["segment"])
        return typing.cast(None, jsii.invoke(self, "addDynamicSegment", [segment]))

    @jsii.member(jsii_name="createDashboard")
    def _create_dashboard(
        self,
        rendering_preference: DashboardRenderingPreference,
        id: builtins.str,
        *,
        dashboard_name: typing.Optional[builtins.str] = None,
        default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        end: typing.Optional[builtins.str] = None,
        period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
        start: typing.Optional[builtins.str] = None,
        variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
        widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard:
        '''
        :param rendering_preference: -
        :param id: -
        :param dashboard_name: Name of the dashboard. If set, must only contain alphanumerics, dash (-) and underscore (_) Default: - automatically generated name
        :param default_interval: Interval duration for metrics. You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)). Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the defaultInterval time will be the default time range.
        :param end: The end of the time range to use for each widget on the dashboard when the dashboard loads. If you specify a value for end, you must also specify a value for start. Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Default: When the dashboard loads, the end date will be the current time.
        :param period_override: Use this field to specify the period for the graphs when the dashboard loads. Specifying ``Auto`` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard. Specifying ``Inherit`` ensures that the period set for each graph is always obeyed. Default: Auto
        :param start: The start of the time range to use for each widget on the dashboard. You can specify start without specifying end to specify a relative time range that ends with the current time. In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months. You can also use start along with an end field, to specify an absolute time range. When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z. Both properties ``defaultInterval`` and ``start`` cannot be set at once. Default: When the dashboard loads, the start time will be the default time range.
        :param variables: A list of dashboard variables. Default: - No variables
        :param widgets: Initial set of widgets on the dashboard. One array represents a row of widgets. Default: - No widgets

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5be96cb7dfe8f1ad920be8bbfc56df1517938d77480eb705bfe8a35e19ae5197)
            check_type(argname="argument rendering_preference", value=rendering_preference, expected_type=type_hints["rendering_preference"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _aws_cdk_aws_cloudwatch_ceddda9d.DashboardProps(
            dashboard_name=dashboard_name,
            default_interval=default_interval,
            end=end,
            period_override=period_override,
            start=start,
            variables=variables,
            widgets=widgets,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard, jsii.invoke(self, "createDashboard", [rendering_preference, id, props]))

    @jsii.member(jsii_name="getDashboard")
    def get_dashboard(
        self,
        type: builtins.str,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''(experimental) Gets the dashboard for the requested dashboard type.

        :param type: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a1487ec2398f4957e8c383fa4d7c98499be2bba7c7294dadc8e5b20c429c543)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "getDashboard", [type]))

    @builtins.property
    @jsii.member(jsii_name="dashboards")
    def dashboards(
        self,
    ) -> typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.get(self, "dashboards"))


class DynamoTableGlobalSecondaryIndexMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamoTableGlobalSecondaryIndexMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        global_secondary_index_name: builtins.str,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_read_throttled_events_count_alarm: 
        :param add_write_throttled_events_count_alarm: 
        :param global_secondary_index_name: 
        :param table: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf171c6831d16b065d161f0dc47fe17d5206b9a08de37d274a06b6293dc37dbf)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = DynamoTableGlobalSecondaryIndexMonitoringProps(
            add_read_throttled_events_count_alarm=add_read_throttled_events_count_alarm,
            add_write_throttled_events_count_alarm=add_write_throttled_events_count_alarm,
            global_secondary_index_name=global_secondary_index_name,
            table=table,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createReadCapacityWidget")
    def _create_read_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__101b7b6cebedbf3da6992804ccb081e45e07e026888d94476f565de837a47bac)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createReadCapacityWidget", [width, height]))

    @jsii.member(jsii_name="createThrottlesWidget")
    def _create_throttles_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e20e8602f5e934026404de3530b5da57acd4f65e717ccf4385991a49b1eaa8e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createThrottlesWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def _create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createWriteCapacityWidget")
    def _create_write_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__641eec8247d6802cbf1102f0f35eae85ac26f2ba70737ebb352e22ca9d4624a8)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createWriteCapacityWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="consumedReadUnitsMetric")
    def _consumed_read_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "consumedReadUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="consumedWriteUnitsMetric")
    def _consumed_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "consumedWriteUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="gsiAlarmFactory")
    def _gsi_alarm_factory(self) -> DynamoAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(DynamoAlarmFactory, jsii.get(self, "gsiAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="indexConsumedWriteUnitsMetric")
    def _index_consumed_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "indexConsumedWriteUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="indexThrottleCountMetric")
    def _index_throttle_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "indexThrottleCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="provisionedReadUnitsMetric")
    def _provisioned_read_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedReadUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="provisionedWriteUnitsMetric")
    def _provisioned_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedWriteUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="readThrottleCountMetric")
    def _read_throttle_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readThrottleCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="throttledEventsAnnotations")
    def _throttled_events_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "throttledEventsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def _title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="writeThrottleCountMetric")
    def _write_throttle_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeThrottleCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="tableUrl")
    def _table_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tableUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamoTableGlobalSecondaryIndexMonitoringProps",
    jsii_struct_bases=[
        DynamoTableGlobalSecondaryIndexMetricFactoryProps, BaseMonitoringProps
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "global_secondary_index_name": "globalSecondaryIndexName",
        "table": "table",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_read_throttled_events_count_alarm": "addReadThrottledEventsCountAlarm",
        "add_write_throttled_events_count_alarm": "addWriteThrottledEventsCountAlarm",
    },
)
class DynamoTableGlobalSecondaryIndexMonitoringProps(
    DynamoTableGlobalSecondaryIndexMetricFactoryProps,
    BaseMonitoringProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        global_secondary_index_name: builtins.str,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param global_secondary_index_name: 
        :param table: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_read_throttled_events_count_alarm: 
        :param add_write_throttled_events_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ee86a5699e86385225c4d433f3a0288275b70a23be96e2e660435973f77e25c)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument global_secondary_index_name", value=global_secondary_index_name, expected_type=type_hints["global_secondary_index_name"])
            check_type(argname="argument table", value=table, expected_type=type_hints["table"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_read_throttled_events_count_alarm", value=add_read_throttled_events_count_alarm, expected_type=type_hints["add_read_throttled_events_count_alarm"])
            check_type(argname="argument add_write_throttled_events_count_alarm", value=add_write_throttled_events_count_alarm, expected_type=type_hints["add_write_throttled_events_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "global_secondary_index_name": global_secondary_index_name,
            "table": table,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_read_throttled_events_count_alarm is not None:
            self._values["add_read_throttled_events_count_alarm"] = add_read_throttled_events_count_alarm
        if add_write_throttled_events_count_alarm is not None:
            self._values["add_write_throttled_events_count_alarm"] = add_write_throttled_events_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def global_secondary_index_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("global_secondary_index_name")
        assert result is not None, "Required property 'global_secondary_index_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''
        :stability: experimental
        '''
        result = self._values.get("table")
        assert result is not None, "Required property 'table' is missing"
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_read_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_read_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    @builtins.property
    def add_write_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_write_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamoTableGlobalSecondaryIndexMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DynamoTableMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DynamoTableMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
        add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param table: (experimental) table to monitor.
        :param billing_mode: (experimental) table billing mode. Default: - best effort auto-detection or PROVISIONED as a fallback
        :param add_average_successful_batch_get_item_latency_alarm: 
        :param add_average_successful_batch_write_item_latency_alarm: 
        :param add_average_successful_delete_item_latency_alarm: 
        :param add_average_successful_get_item_latency_alarm: 
        :param add_average_successful_get_records_latency_alarm: 
        :param add_average_successful_put_item_latency_alarm: 
        :param add_average_successful_query_latency_alarm: 
        :param add_average_successful_scan_latency_alarm: 
        :param add_average_successful_update_item_latency_alarm: 
        :param add_consumed_read_capacity_alarm: 
        :param add_consumed_write_capacity_alarm: 
        :param add_min_time_to_live_deleted_item_count_alarm: 
        :param add_read_throttled_events_count_alarm: 
        :param add_system_error_count_alarm: 
        :param add_write_throttled_events_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca296110c2e29e52184e6066df2f88917a844b14e1db76d6b21baa01f993de9c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = DynamoTableMonitoringProps(
            table=table,
            billing_mode=billing_mode,
            add_average_successful_batch_get_item_latency_alarm=add_average_successful_batch_get_item_latency_alarm,
            add_average_successful_batch_write_item_latency_alarm=add_average_successful_batch_write_item_latency_alarm,
            add_average_successful_delete_item_latency_alarm=add_average_successful_delete_item_latency_alarm,
            add_average_successful_get_item_latency_alarm=add_average_successful_get_item_latency_alarm,
            add_average_successful_get_records_latency_alarm=add_average_successful_get_records_latency_alarm,
            add_average_successful_put_item_latency_alarm=add_average_successful_put_item_latency_alarm,
            add_average_successful_query_latency_alarm=add_average_successful_query_latency_alarm,
            add_average_successful_scan_latency_alarm=add_average_successful_scan_latency_alarm,
            add_average_successful_update_item_latency_alarm=add_average_successful_update_item_latency_alarm,
            add_consumed_read_capacity_alarm=add_consumed_read_capacity_alarm,
            add_consumed_write_capacity_alarm=add_consumed_write_capacity_alarm,
            add_min_time_to_live_deleted_item_count_alarm=add_min_time_to_live_deleted_item_count_alarm,
            add_read_throttled_events_count_alarm=add_read_throttled_events_count_alarm,
            add_system_error_count_alarm=add_system_error_count_alarm,
            add_write_throttled_events_count_alarm=add_write_throttled_events_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorsWidget")
    def create_errors_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ac1780f164da0e5bf393be145310d5cbc8e5c5152fe6d4d495ae66edae7cefb6)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorsWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f976d265ab30e5f98d88f2916e88326f387c47b194f8475cf8f7b627bd93ed4e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createReadCapacityWidget")
    def create_read_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b9a403c596c812f203b5dd92327182806e69937795789d62ebcddd3e2f726d0)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createReadCapacityWidget", [width, height]))

    @jsii.member(jsii_name="createThrottlesWidget")
    def create_throttles_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48ed1306b832ef6248189726513e3cf36f3d485d8a84a40c0e76f1ef62f32a45)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createThrottlesWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createWriteCapacityWidget")
    def create_write_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7e96c371880b8d3767c028eb5123e7bbe5f75711df28fec58bc169851365b42)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createWriteCapacityWidget", [width, height]))

    @jsii.member(jsii_name="forEachOperationLatencyAlarmDefinition")
    def _for_each_operation_latency_alarm_definition(
        self,
        operation: _aws_cdk_aws_dynamodb_ceddda9d.Operation,
        alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param operation: -
        :param alarm: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__88ff626ba268b68176d1c727f30e4bfdeac33b29530324acddd70fd2d9a74595)
            check_type(argname="argument operation", value=operation, expected_type=type_hints["operation"])
            check_type(argname="argument alarm", value=alarm, expected_type=type_hints["alarm"])
        return typing.cast(None, jsii.invoke(self, "forEachOperationLatencyAlarmDefinition", [operation, alarm]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="averagePerOperationLatencyMetrics")
    def average_per_operation_latency_metrics(
        self,
    ) -> typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "averagePerOperationLatencyMetrics"))

    @builtins.property
    @jsii.member(jsii_name="consumedReadUnitsMetric")
    def consumed_read_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "consumedReadUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="consumedWriteUnitsMetric")
    def consumed_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "consumedWriteUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="dynamoCapacityAlarmFactory")
    def dynamo_capacity_alarm_factory(self) -> DynamoAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(DynamoAlarmFactory, jsii.get(self, "dynamoCapacityAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="dynamoReadCapacityAnnotations")
    def dynamo_read_capacity_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "dynamoReadCapacityAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="dynamoWriteCapacityAnnotations")
    def dynamo_write_capacity_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "dynamoWriteCapacityAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="latencyAverageSearchMetrics")
    def latency_average_search_metrics(
        self,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.IMetric:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.IMetric, jsii.get(self, "latencyAverageSearchMetrics"))

    @builtins.property
    @jsii.member(jsii_name="provisionedReadUnitsMetric")
    def provisioned_read_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedReadUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="provisionedWriteUnitsMetric")
    def provisioned_write_units_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedWriteUnitsMetric"))

    @builtins.property
    @jsii.member(jsii_name="readCapacityUsageMetric")
    def read_capacity_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readCapacityUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="readThrottleCountMetric")
    def read_throttle_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readThrottleCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="systemErrorMetric")
    def system_error_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "systemErrorMetric"))

    @builtins.property
    @jsii.member(jsii_name="tableBillingMode")
    def table_billing_mode(self) -> _aws_cdk_aws_dynamodb_ceddda9d.BillingMode:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.BillingMode, jsii.get(self, "tableBillingMode"))

    @builtins.property
    @jsii.member(jsii_name="throttledEventsAnnotations")
    def throttled_events_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "throttledEventsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="timeToLiveDeletedItemCountMetric")
    def time_to_live_deleted_item_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "timeToLiveDeletedItemCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="writeCapacityUsageMetric")
    def write_capacity_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeCapacityUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="writeThrottleCountMetric")
    def write_throttle_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeThrottleCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="tableUrl")
    def table_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tableUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamoTableMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_average_successful_batch_get_item_latency_alarm": "addAverageSuccessfulBatchGetItemLatencyAlarm",
        "add_average_successful_batch_write_item_latency_alarm": "addAverageSuccessfulBatchWriteItemLatencyAlarm",
        "add_average_successful_delete_item_latency_alarm": "addAverageSuccessfulDeleteItemLatencyAlarm",
        "add_average_successful_get_item_latency_alarm": "addAverageSuccessfulGetItemLatencyAlarm",
        "add_average_successful_get_records_latency_alarm": "addAverageSuccessfulGetRecordsLatencyAlarm",
        "add_average_successful_put_item_latency_alarm": "addAverageSuccessfulPutItemLatencyAlarm",
        "add_average_successful_query_latency_alarm": "addAverageSuccessfulQueryLatencyAlarm",
        "add_average_successful_scan_latency_alarm": "addAverageSuccessfulScanLatencyAlarm",
        "add_average_successful_update_item_latency_alarm": "addAverageSuccessfulUpdateItemLatencyAlarm",
        "add_consumed_read_capacity_alarm": "addConsumedReadCapacityAlarm",
        "add_consumed_write_capacity_alarm": "addConsumedWriteCapacityAlarm",
        "add_min_time_to_live_deleted_item_count_alarm": "addMinTimeToLiveDeletedItemCountAlarm",
        "add_read_throttled_events_count_alarm": "addReadThrottledEventsCountAlarm",
        "add_system_error_count_alarm": "addSystemErrorCountAlarm",
        "add_write_throttled_events_count_alarm": "addWriteThrottledEventsCountAlarm",
    },
)
class DynamoTableMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_average_successful_batch_get_item_latency_alarm: 
        :param add_average_successful_batch_write_item_latency_alarm: 
        :param add_average_successful_delete_item_latency_alarm: 
        :param add_average_successful_get_item_latency_alarm: 
        :param add_average_successful_get_records_latency_alarm: 
        :param add_average_successful_put_item_latency_alarm: 
        :param add_average_successful_query_latency_alarm: 
        :param add_average_successful_scan_latency_alarm: 
        :param add_average_successful_update_item_latency_alarm: 
        :param add_consumed_read_capacity_alarm: 
        :param add_consumed_write_capacity_alarm: 
        :param add_min_time_to_live_deleted_item_count_alarm: 
        :param add_read_throttled_events_count_alarm: 
        :param add_system_error_count_alarm: 
        :param add_write_throttled_events_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb159b396feffebf1b7829b15c1b2264dc6ed9389a5a1644d19296e3f60de944)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_average_successful_batch_get_item_latency_alarm", value=add_average_successful_batch_get_item_latency_alarm, expected_type=type_hints["add_average_successful_batch_get_item_latency_alarm"])
            check_type(argname="argument add_average_successful_batch_write_item_latency_alarm", value=add_average_successful_batch_write_item_latency_alarm, expected_type=type_hints["add_average_successful_batch_write_item_latency_alarm"])
            check_type(argname="argument add_average_successful_delete_item_latency_alarm", value=add_average_successful_delete_item_latency_alarm, expected_type=type_hints["add_average_successful_delete_item_latency_alarm"])
            check_type(argname="argument add_average_successful_get_item_latency_alarm", value=add_average_successful_get_item_latency_alarm, expected_type=type_hints["add_average_successful_get_item_latency_alarm"])
            check_type(argname="argument add_average_successful_get_records_latency_alarm", value=add_average_successful_get_records_latency_alarm, expected_type=type_hints["add_average_successful_get_records_latency_alarm"])
            check_type(argname="argument add_average_successful_put_item_latency_alarm", value=add_average_successful_put_item_latency_alarm, expected_type=type_hints["add_average_successful_put_item_latency_alarm"])
            check_type(argname="argument add_average_successful_query_latency_alarm", value=add_average_successful_query_latency_alarm, expected_type=type_hints["add_average_successful_query_latency_alarm"])
            check_type(argname="argument add_average_successful_scan_latency_alarm", value=add_average_successful_scan_latency_alarm, expected_type=type_hints["add_average_successful_scan_latency_alarm"])
            check_type(argname="argument add_average_successful_update_item_latency_alarm", value=add_average_successful_update_item_latency_alarm, expected_type=type_hints["add_average_successful_update_item_latency_alarm"])
            check_type(argname="argument add_consumed_read_capacity_alarm", value=add_consumed_read_capacity_alarm, expected_type=type_hints["add_consumed_read_capacity_alarm"])
            check_type(argname="argument add_consumed_write_capacity_alarm", value=add_consumed_write_capacity_alarm, expected_type=type_hints["add_consumed_write_capacity_alarm"])
            check_type(argname="argument add_min_time_to_live_deleted_item_count_alarm", value=add_min_time_to_live_deleted_item_count_alarm, expected_type=type_hints["add_min_time_to_live_deleted_item_count_alarm"])
            check_type(argname="argument add_read_throttled_events_count_alarm", value=add_read_throttled_events_count_alarm, expected_type=type_hints["add_read_throttled_events_count_alarm"])
            check_type(argname="argument add_system_error_count_alarm", value=add_system_error_count_alarm, expected_type=type_hints["add_system_error_count_alarm"])
            check_type(argname="argument add_write_throttled_events_count_alarm", value=add_write_throttled_events_count_alarm, expected_type=type_hints["add_write_throttled_events_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_average_successful_batch_get_item_latency_alarm is not None:
            self._values["add_average_successful_batch_get_item_latency_alarm"] = add_average_successful_batch_get_item_latency_alarm
        if add_average_successful_batch_write_item_latency_alarm is not None:
            self._values["add_average_successful_batch_write_item_latency_alarm"] = add_average_successful_batch_write_item_latency_alarm
        if add_average_successful_delete_item_latency_alarm is not None:
            self._values["add_average_successful_delete_item_latency_alarm"] = add_average_successful_delete_item_latency_alarm
        if add_average_successful_get_item_latency_alarm is not None:
            self._values["add_average_successful_get_item_latency_alarm"] = add_average_successful_get_item_latency_alarm
        if add_average_successful_get_records_latency_alarm is not None:
            self._values["add_average_successful_get_records_latency_alarm"] = add_average_successful_get_records_latency_alarm
        if add_average_successful_put_item_latency_alarm is not None:
            self._values["add_average_successful_put_item_latency_alarm"] = add_average_successful_put_item_latency_alarm
        if add_average_successful_query_latency_alarm is not None:
            self._values["add_average_successful_query_latency_alarm"] = add_average_successful_query_latency_alarm
        if add_average_successful_scan_latency_alarm is not None:
            self._values["add_average_successful_scan_latency_alarm"] = add_average_successful_scan_latency_alarm
        if add_average_successful_update_item_latency_alarm is not None:
            self._values["add_average_successful_update_item_latency_alarm"] = add_average_successful_update_item_latency_alarm
        if add_consumed_read_capacity_alarm is not None:
            self._values["add_consumed_read_capacity_alarm"] = add_consumed_read_capacity_alarm
        if add_consumed_write_capacity_alarm is not None:
            self._values["add_consumed_write_capacity_alarm"] = add_consumed_write_capacity_alarm
        if add_min_time_to_live_deleted_item_count_alarm is not None:
            self._values["add_min_time_to_live_deleted_item_count_alarm"] = add_min_time_to_live_deleted_item_count_alarm
        if add_read_throttled_events_count_alarm is not None:
            self._values["add_read_throttled_events_count_alarm"] = add_read_throttled_events_count_alarm
        if add_system_error_count_alarm is not None:
            self._values["add_system_error_count_alarm"] = add_system_error_count_alarm
        if add_write_throttled_events_count_alarm is not None:
            self._values["add_write_throttled_events_count_alarm"] = add_write_throttled_events_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_average_successful_batch_get_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_batch_get_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_batch_write_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_batch_write_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_delete_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_delete_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_get_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_get_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_get_records_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_get_records_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_put_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_put_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_query_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_query_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_scan_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_scan_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_update_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_update_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_consumed_read_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_consumed_read_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]], result)

    @builtins.property
    def add_consumed_write_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_consumed_write_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]], result)

    @builtins.property
    def add_min_time_to_live_deleted_item_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_time_to_live_deleted_item_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_read_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_read_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    @builtins.property
    def add_system_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_system_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_write_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_write_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamoTableMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.DynamoTableMonitoringProps",
    jsii_struct_bases=[DynamoTableMetricFactoryProps, DynamoTableMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "table": "table",
        "billing_mode": "billingMode",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_average_successful_batch_get_item_latency_alarm": "addAverageSuccessfulBatchGetItemLatencyAlarm",
        "add_average_successful_batch_write_item_latency_alarm": "addAverageSuccessfulBatchWriteItemLatencyAlarm",
        "add_average_successful_delete_item_latency_alarm": "addAverageSuccessfulDeleteItemLatencyAlarm",
        "add_average_successful_get_item_latency_alarm": "addAverageSuccessfulGetItemLatencyAlarm",
        "add_average_successful_get_records_latency_alarm": "addAverageSuccessfulGetRecordsLatencyAlarm",
        "add_average_successful_put_item_latency_alarm": "addAverageSuccessfulPutItemLatencyAlarm",
        "add_average_successful_query_latency_alarm": "addAverageSuccessfulQueryLatencyAlarm",
        "add_average_successful_scan_latency_alarm": "addAverageSuccessfulScanLatencyAlarm",
        "add_average_successful_update_item_latency_alarm": "addAverageSuccessfulUpdateItemLatencyAlarm",
        "add_consumed_read_capacity_alarm": "addConsumedReadCapacityAlarm",
        "add_consumed_write_capacity_alarm": "addConsumedWriteCapacityAlarm",
        "add_min_time_to_live_deleted_item_count_alarm": "addMinTimeToLiveDeletedItemCountAlarm",
        "add_read_throttled_events_count_alarm": "addReadThrottledEventsCountAlarm",
        "add_system_error_count_alarm": "addSystemErrorCountAlarm",
        "add_write_throttled_events_count_alarm": "addWriteThrottledEventsCountAlarm",
    },
)
class DynamoTableMonitoringProps(
    DynamoTableMetricFactoryProps,
    DynamoTableMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param table: (experimental) table to monitor.
        :param billing_mode: (experimental) table billing mode. Default: - best effort auto-detection or PROVISIONED as a fallback
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_average_successful_batch_get_item_latency_alarm: 
        :param add_average_successful_batch_write_item_latency_alarm: 
        :param add_average_successful_delete_item_latency_alarm: 
        :param add_average_successful_get_item_latency_alarm: 
        :param add_average_successful_get_records_latency_alarm: 
        :param add_average_successful_put_item_latency_alarm: 
        :param add_average_successful_query_latency_alarm: 
        :param add_average_successful_scan_latency_alarm: 
        :param add_average_successful_update_item_latency_alarm: 
        :param add_consumed_read_capacity_alarm: 
        :param add_consumed_write_capacity_alarm: 
        :param add_min_time_to_live_deleted_item_count_alarm: 
        :param add_read_throttled_events_count_alarm: 
        :param add_system_error_count_alarm: 
        :param add_write_throttled_events_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49700202abdedb811650d2ad77a26e8bdce4a39c9a97e0298976d8e057a0ff51)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument table", value=table, expected_type=type_hints["table"])
            check_type(argname="argument billing_mode", value=billing_mode, expected_type=type_hints["billing_mode"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_average_successful_batch_get_item_latency_alarm", value=add_average_successful_batch_get_item_latency_alarm, expected_type=type_hints["add_average_successful_batch_get_item_latency_alarm"])
            check_type(argname="argument add_average_successful_batch_write_item_latency_alarm", value=add_average_successful_batch_write_item_latency_alarm, expected_type=type_hints["add_average_successful_batch_write_item_latency_alarm"])
            check_type(argname="argument add_average_successful_delete_item_latency_alarm", value=add_average_successful_delete_item_latency_alarm, expected_type=type_hints["add_average_successful_delete_item_latency_alarm"])
            check_type(argname="argument add_average_successful_get_item_latency_alarm", value=add_average_successful_get_item_latency_alarm, expected_type=type_hints["add_average_successful_get_item_latency_alarm"])
            check_type(argname="argument add_average_successful_get_records_latency_alarm", value=add_average_successful_get_records_latency_alarm, expected_type=type_hints["add_average_successful_get_records_latency_alarm"])
            check_type(argname="argument add_average_successful_put_item_latency_alarm", value=add_average_successful_put_item_latency_alarm, expected_type=type_hints["add_average_successful_put_item_latency_alarm"])
            check_type(argname="argument add_average_successful_query_latency_alarm", value=add_average_successful_query_latency_alarm, expected_type=type_hints["add_average_successful_query_latency_alarm"])
            check_type(argname="argument add_average_successful_scan_latency_alarm", value=add_average_successful_scan_latency_alarm, expected_type=type_hints["add_average_successful_scan_latency_alarm"])
            check_type(argname="argument add_average_successful_update_item_latency_alarm", value=add_average_successful_update_item_latency_alarm, expected_type=type_hints["add_average_successful_update_item_latency_alarm"])
            check_type(argname="argument add_consumed_read_capacity_alarm", value=add_consumed_read_capacity_alarm, expected_type=type_hints["add_consumed_read_capacity_alarm"])
            check_type(argname="argument add_consumed_write_capacity_alarm", value=add_consumed_write_capacity_alarm, expected_type=type_hints["add_consumed_write_capacity_alarm"])
            check_type(argname="argument add_min_time_to_live_deleted_item_count_alarm", value=add_min_time_to_live_deleted_item_count_alarm, expected_type=type_hints["add_min_time_to_live_deleted_item_count_alarm"])
            check_type(argname="argument add_read_throttled_events_count_alarm", value=add_read_throttled_events_count_alarm, expected_type=type_hints["add_read_throttled_events_count_alarm"])
            check_type(argname="argument add_system_error_count_alarm", value=add_system_error_count_alarm, expected_type=type_hints["add_system_error_count_alarm"])
            check_type(argname="argument add_write_throttled_events_count_alarm", value=add_write_throttled_events_count_alarm, expected_type=type_hints["add_write_throttled_events_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "table": table,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if billing_mode is not None:
            self._values["billing_mode"] = billing_mode
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_average_successful_batch_get_item_latency_alarm is not None:
            self._values["add_average_successful_batch_get_item_latency_alarm"] = add_average_successful_batch_get_item_latency_alarm
        if add_average_successful_batch_write_item_latency_alarm is not None:
            self._values["add_average_successful_batch_write_item_latency_alarm"] = add_average_successful_batch_write_item_latency_alarm
        if add_average_successful_delete_item_latency_alarm is not None:
            self._values["add_average_successful_delete_item_latency_alarm"] = add_average_successful_delete_item_latency_alarm
        if add_average_successful_get_item_latency_alarm is not None:
            self._values["add_average_successful_get_item_latency_alarm"] = add_average_successful_get_item_latency_alarm
        if add_average_successful_get_records_latency_alarm is not None:
            self._values["add_average_successful_get_records_latency_alarm"] = add_average_successful_get_records_latency_alarm
        if add_average_successful_put_item_latency_alarm is not None:
            self._values["add_average_successful_put_item_latency_alarm"] = add_average_successful_put_item_latency_alarm
        if add_average_successful_query_latency_alarm is not None:
            self._values["add_average_successful_query_latency_alarm"] = add_average_successful_query_latency_alarm
        if add_average_successful_scan_latency_alarm is not None:
            self._values["add_average_successful_scan_latency_alarm"] = add_average_successful_scan_latency_alarm
        if add_average_successful_update_item_latency_alarm is not None:
            self._values["add_average_successful_update_item_latency_alarm"] = add_average_successful_update_item_latency_alarm
        if add_consumed_read_capacity_alarm is not None:
            self._values["add_consumed_read_capacity_alarm"] = add_consumed_read_capacity_alarm
        if add_consumed_write_capacity_alarm is not None:
            self._values["add_consumed_write_capacity_alarm"] = add_consumed_write_capacity_alarm
        if add_min_time_to_live_deleted_item_count_alarm is not None:
            self._values["add_min_time_to_live_deleted_item_count_alarm"] = add_min_time_to_live_deleted_item_count_alarm
        if add_read_throttled_events_count_alarm is not None:
            self._values["add_read_throttled_events_count_alarm"] = add_read_throttled_events_count_alarm
        if add_system_error_count_alarm is not None:
            self._values["add_system_error_count_alarm"] = add_system_error_count_alarm
        if add_write_throttled_events_count_alarm is not None:
            self._values["add_write_throttled_events_count_alarm"] = add_write_throttled_events_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def table(self) -> _aws_cdk_aws_dynamodb_ceddda9d.ITable:
        '''(experimental) table to monitor.

        :stability: experimental
        '''
        result = self._values.get("table")
        assert result is not None, "Required property 'table' is missing"
        return typing.cast(_aws_cdk_aws_dynamodb_ceddda9d.ITable, result)

    @builtins.property
    def billing_mode(
        self,
    ) -> typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode]:
        '''(experimental) table billing mode.

        :default: - best effort auto-detection or PROVISIONED as a fallback

        :stability: experimental
        '''
        result = self._values.get("billing_mode")
        return typing.cast(typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_average_successful_batch_get_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_batch_get_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_batch_write_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_batch_write_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_delete_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_delete_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_get_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_get_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_get_records_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_get_records_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_put_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_put_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_query_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_query_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_scan_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_scan_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_average_successful_update_item_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_successful_update_item_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_consumed_read_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_consumed_read_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]], result)

    @builtins.property
    def add_consumed_write_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_consumed_write_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ConsumedCapacityThreshold]], result)

    @builtins.property
    def add_min_time_to_live_deleted_item_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_time_to_live_deleted_item_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_read_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_read_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    @builtins.property
    def add_system_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_system_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_write_throttled_events_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_write_throttled_events_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ThrottledEventsThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DynamoTableMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class EC2Monitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.EC2Monitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9044560fc291196c2f3f049a458125431528e7d078d4afe65ced354168813c22)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = EC2MonitoringProps(
            auto_scaling_group=auto_scaling_group,
            instance_ids=instance_ids,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createCpuWidget")
    def create_cpu_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1203c8a9a5145b1937fdb9b958dc702828c61bf030917c7b75d0f7238f4bc73)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuWidget", [width, height]))

    @jsii.member(jsii_name="createDiskOpsWidget")
    def create_disk_ops_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b9145251a3cc982a238b788c37ee02485427ccfc4d3a3c1afa4d094d2bb0d399)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDiskOpsWidget", [width, height]))

    @jsii.member(jsii_name="createDiskWidget")
    def create_disk_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__413815ba080f1de4f37738ddff41176478a39a267cc73a4ec549533e13b28a4d)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDiskWidget", [width, height]))

    @jsii.member(jsii_name="createNetworkWidget")
    def create_network_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2f2dceb070988be0b6142ebddf7801f6db293b4adaa23ca4a3c1ad5cf755623)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createNetworkWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="cpuUtilisationMetrics")
    def cpu_utilisation_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "cpuUtilisationMetrics"))

    @builtins.property
    @jsii.member(jsii_name="diskReadBytesMetrics")
    def disk_read_bytes_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "diskReadBytesMetrics"))

    @builtins.property
    @jsii.member(jsii_name="diskReadOpsMetrics")
    def disk_read_ops_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "diskReadOpsMetrics"))

    @builtins.property
    @jsii.member(jsii_name="diskWriteBytesMetrics")
    def disk_write_bytes_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "diskWriteBytesMetrics"))

    @builtins.property
    @jsii.member(jsii_name="diskWriteOpsMetrics")
    def disk_write_ops_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "diskWriteOpsMetrics"))

    @builtins.property
    @jsii.member(jsii_name="family")
    def family(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "family"))

    @builtins.property
    @jsii.member(jsii_name="networkInMetrics")
    def network_in_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "networkInMetrics"))

    @builtins.property
    @jsii.member(jsii_name="networkOutMetrics")
    def network_out_metrics(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric], jsii.get(self, "networkOutMetrics"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.EC2MonitoringOptions",
    jsii_struct_bases=[EC2MetricFactoryProps, BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "auto_scaling_group": "autoScalingGroup",
        "instance_ids": "instanceIds",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class EC2MonitoringOptions(EC2MetricFactoryProps, BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0184606d6c3010e92399005956d361106afd5f90cd5bf12b900554ee875664f5)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
            check_type(argname="argument instance_ids", value=instance_ids, expected_type=type_hints["instance_ids"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if auto_scaling_group is not None:
            self._values["auto_scaling_group"] = auto_scaling_group
        if instance_ids is not None:
            self._values["instance_ids"] = instance_ids
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_scaling_group(
        self,
    ) -> typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup]:
        '''(experimental) Auto-Scaling Group to monitor.

        :default: - no Auto-Scaling Group filter

        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        return typing.cast(typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup], result)

    @builtins.property
    def instance_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Selected IDs of EC2 instances to monitor.

        :default: - no instance filter

        :stability: experimental
        '''
        result = self._values.get("instance_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EC2MonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.EC2MonitoringProps",
    jsii_struct_bases=[EC2MonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "auto_scaling_group": "autoScalingGroup",
        "instance_ids": "instanceIds",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class EC2MonitoringProps(EC2MonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__858c0d13aa43c10ef51db716a9b96ffed8af35614d16d917d50be61ffa5469a9)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
            check_type(argname="argument instance_ids", value=instance_ids, expected_type=type_hints["instance_ids"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if auto_scaling_group is not None:
            self._values["auto_scaling_group"] = auto_scaling_group
        if instance_ids is not None:
            self._values["instance_ids"] = instance_ids
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_scaling_group(
        self,
    ) -> typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup]:
        '''(experimental) Auto-Scaling Group to monitor.

        :default: - no Auto-Scaling Group filter

        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        return typing.cast(typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup], result)

    @builtins.property
    def instance_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Selected IDs of EC2 instances to monitor.

        :default: - no instance filter

        :stability: experimental
        '''
        result = self._values.get("instance_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EC2MonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.Ec2ApplicationLoadBalancerMonitoringProps",
    jsii_struct_bases=[
        ApplicationLoadBalancerMetricFactoryProps,
        BaseMonitoringProps,
        BaseEc2ServiceAlarms,
    ],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "application_load_balancer": "applicationLoadBalancer",
        "application_target_group": "applicationTargetGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "ec2_service": "ec2Service",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class Ec2ApplicationLoadBalancerMonitoringProps(
    ApplicationLoadBalancerMetricFactoryProps,
    BaseMonitoringProps,
    BaseEc2ServiceAlarms,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for EC2 service with application load balancer and plain service.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param application_load_balancer: 
        :param application_target_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__632219ed38efb376e5f5e7c65d328884c8ec2d4dc5caae29b003d62117d2b39d)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument application_load_balancer", value=application_load_balancer, expected_type=type_hints["application_load_balancer"])
            check_type(argname="argument application_target_group", value=application_target_group, expected_type=type_hints["application_target_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application_load_balancer": application_load_balancer,
            "application_target_group": application_target_group,
            "ec2_service": ec2_service,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def application_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_load_balancer")
        assert result is not None, "Required property 'application_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, result)

    @builtins.property
    def application_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_target_group")
        assert result is not None, "Required property 'application_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ec2_service(self) -> _aws_cdk_aws_ecs_ceddda9d.Ec2Service:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.Ec2Service, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "Ec2ApplicationLoadBalancerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.Ec2NetworkLoadBalancerMonitoringProps",
    jsii_struct_bases=[
        NetworkLoadBalancerMetricFactoryProps,
        BaseMonitoringProps,
        BaseEc2ServiceAlarms,
    ],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "network_load_balancer": "networkLoadBalancer",
        "network_target_group": "networkTargetGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "ec2_service": "ec2Service",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class Ec2NetworkLoadBalancerMonitoringProps(
    NetworkLoadBalancerMetricFactoryProps,
    BaseMonitoringProps,
    BaseEc2ServiceAlarms,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for EC2 service with network load balancer and plain service.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param network_load_balancer: 
        :param network_target_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cfa00e8d209ffb05b37dc20b1dcb3518d9e879b995d834b51fafcf22750ea6d)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument network_load_balancer", value=network_load_balancer, expected_type=type_hints["network_load_balancer"])
            check_type(argname="argument network_target_group", value=network_target_group, expected_type=type_hints["network_target_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_load_balancer": network_load_balancer,
            "network_target_group": network_target_group,
            "ec2_service": ec2_service,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_load_balancer")
        assert result is not None, "Required property 'network_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer, result)

    @builtins.property
    def network_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_target_group")
        assert result is not None, "Required property 'network_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ec2_service(self) -> _aws_cdk_aws_ecs_ceddda9d.Ec2Service:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.Ec2Service, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "Ec2NetworkLoadBalancerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class Ec2ServiceMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.Ec2ServiceMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
        target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param load_balancer: 
        :param target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ad343fffff4cc79130a4ea22a3f3866c4c1cc64a5e4cb04f14b0d92d6952388f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CustomEc2ServiceMonitoringProps(
            ec2_service=ec2_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            load_balancer=load_balancer,
            target_group=target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createCpuWidget")
    def create_cpu_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6803498f214d1b09005eb86a5df825f4c93ccbaded6cd9a18738b14a9213ed91)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuWidget", [width, height]))

    @jsii.member(jsii_name="createMemoryWidget")
    def create_memory_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__abfb1e74912bc7316618942fd082a2b6e8a17e3419b4c7749c23fb006d0a1cd1)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMemoryWidget", [width, height]))

    @jsii.member(jsii_name="createTaskHealthWidget")
    def create_task_health_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff6d0f1f3b4983d42f00be6665cc2fa8f913726e15ed2dea216448429c0ad9f1)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTaskHealthWidget", [width, height]))

    @jsii.member(jsii_name="createTcpFlowsWidget")
    def create_tcp_flows_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0fc83651f96213ba15c624e7b185ae834aa40c940655a8dfbf57ad83c509092b)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTcpFlowsWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpcFlowsWidget")
    def create_tpc_flows_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :deprecated: use {

        :see: createTcpFlowsWidget} instead.
        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b8a9b872e1c76861f8eb0b70375c97d3116290faf83d491793b8b253642df70)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpcFlowsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="baseServiceMetricFactory")
    def base_service_metric_factory(self) -> BaseServiceMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(BaseServiceMetricFactory, jsii.get(self, "baseServiceMetricFactory"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageAnnotations")
    def cpu_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "cpuUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="cpuUtilisationMetric")
    def cpu_utilisation_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUtilisationMetric"))

    @builtins.property
    @jsii.member(jsii_name="ephemeralStorageUsageMetric")
    def ephemeral_storage_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "ephemeralStorageUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="memoryUsageAnnotations")
    def memory_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "memoryUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="memoryUtilisationMetric")
    def memory_utilisation_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "memoryUtilisationMetric"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def metric_factory(self) -> MetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(MetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesAnnotations")
    def processed_bytes_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "processedBytesAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="runningTaskCountMetric")
    def running_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "runningTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAlarmFactory")
    def task_health_alarm_factory(self) -> TaskHealthAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TaskHealthAlarmFactory, jsii.get(self, "taskHealthAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAnnotations")
    def task_health_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "taskHealthAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="throughputAlarmFactory")
    def throughput_alarm_factory(self) -> ThroughputAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ThroughputAlarmFactory, jsii.get(self, "throughputAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="activeTcpFlowCountMetric")
    def active_tcp_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "activeTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskCountMetric")
    def healthy_task_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "healthyTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskPercentMetric")
    def healthy_task_percent_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "healthyTaskPercentMetric"))

    @builtins.property
    @jsii.member(jsii_name="loadBalancerMetricFactory")
    def load_balancer_metric_factory(
        self,
    ) -> typing.Optional[ILoadBalancerMetricFactory]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ILoadBalancerMetricFactory], jsii.get(self, "loadBalancerMetricFactory"))

    @builtins.property
    @jsii.member(jsii_name="newTcpFlowCountMetric")
    def new_tcp_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "newTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesMetric")
    def processed_bytes_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "processedBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyRoutingFlowCountMetric")
    def unhealthy_routing_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "unhealthyRoutingFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyTaskCountMetric")
    def unhealthy_task_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "unhealthyTaskCountMetric"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.Ec2ServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseEc2ServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "ec2_service": "ec2Service",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class Ec2ServiceMonitoringProps(BaseMonitoringProps, BaseEc2ServiceAlarms):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        ec2_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedEc2Service, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedEc2Service],
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for load-balanced EC2 service.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de28af7d1d92899f2f98108192667cdca5e74943e210891771f0cc037f39bece)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ec2_service": ec2_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ec2_service(
        self,
    ) -> typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedEc2Service, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedEc2Service]:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedEc2Service, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedEc2Service], result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "Ec2ServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ElastiCacheClusterMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ElastiCacheClusterMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        cluster_id: typing.Optional[builtins.str] = None,
        cluster_type: ElastiCacheClusterType,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param cluster_id: (experimental) Cluster to monitor. Default: - monitor all clusters
        :param cluster_type: (experimental) Cluster type (needed, since each type has their own specific metrics).
        :param add_cpu_usage_alarm: (experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).
        :param add_max_evicted_items_count_alarm: (experimental) Add alarm on number of evicted items.
        :param add_max_items_count_alarm: (experimental) Add alarm on total number of items.
        :param add_max_used_swap_memory_alarm: (experimental) Add alarm on amount of used swap memory.
        :param add_min_freeable_memory_alarm: (experimental) Add alarm on amount of freeable memory.
        :param add_redis_engine_cpu_usage_alarm: (experimental) Add Redis engine CPU usage alarm. It is recommended to monitor CPU utilization with ``addCpuUsageAlarm`` as well for hosts with two vCPUs or less.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a5242bec0be6d9e8f17f1bc52457d694368307f7b0278a492167968690c3191c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = ElastiCacheClusterMonitoringProps(
            cluster_id=cluster_id,
            cluster_type=cluster_type,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_max_evicted_items_count_alarm=add_max_evicted_items_count_alarm,
            add_max_items_count_alarm=add_max_items_count_alarm,
            add_max_used_swap_memory_alarm=add_max_used_swap_memory_alarm,
            add_min_freeable_memory_alarm=add_min_freeable_memory_alarm,
            add_redis_engine_cpu_usage_alarm=add_redis_engine_cpu_usage_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConnectionsWidget")
    def create_connections_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1cdb70015a9d7c70692e9c51dd42163190aaf55339f09465b3e91a1fce91d9f5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConnectionsWidget", [width, height]))

    @jsii.member(jsii_name="createCpuUsageWidget")
    def create_cpu_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b709041e73dfed8e3e5be477e2ddf1f170a5f54f846a9594ca52cadcca795a18)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuUsageWidget", [width, height]))

    @jsii.member(jsii_name="createItemCountWidget")
    def create_item_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39da7f042e2f5484f8c202edfc458e0b6bcd6ac1697fbb4f0ac900e94b197918)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createItemCountWidget", [width, height]))

    @jsii.member(jsii_name="createMemoryUsageWidget")
    def create_memory_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f325ee204e22331502b5240c59a5b331b753e5289df5f7efb56c41eeeff1dfa0)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMemoryUsageWidget", [width, height]))

    @jsii.member(jsii_name="createRedisEngineCpuUsageWidget")
    def create_redis_engine_cpu_usage_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5c853e318f7720d551e3d80ffa10219defbcf199968e02b10d716fc70c9a9282)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createRedisEngineCpuUsageWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="clusterType")
    def cluster_type(self) -> ElastiCacheClusterType:
        '''
        :stability: experimental
        '''
        return typing.cast(ElastiCacheClusterType, jsii.get(self, "clusterType"))

    @builtins.property
    @jsii.member(jsii_name="connectionsMetric")
    def connections_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "connectionsMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageAnnotations")
    def cpu_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "cpuUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="elastiCacheAlarmFactory")
    def elasti_cache_alarm_factory(self) -> ElastiCacheAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ElastiCacheAlarmFactory, jsii.get(self, "elastiCacheAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="evictedItemsCountAnnotations")
    def evicted_items_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "evictedItemsCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="freeableMemoryMetric")
    def freeable_memory_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "freeableMemoryMetric"))

    @builtins.property
    @jsii.member(jsii_name="itemsCountAnnotations")
    def items_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "itemsCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="itemsCountMetrics")
    def items_count_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "itemsCountMetrics"))

    @builtins.property
    @jsii.member(jsii_name="itemsEvictedMetrics")
    def items_evicted_metrics(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "itemsEvictedMetrics"))

    @builtins.property
    @jsii.member(jsii_name="itemsMemoryMetric")
    def items_memory_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "itemsMemoryMetric"))

    @builtins.property
    @jsii.member(jsii_name="memoryUsageAnnotations")
    def memory_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "memoryUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="redisEngineCpuUsageAnnotations")
    def redis_engine_cpu_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "redisEngineCpuUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="redisEngineCpuUsageMetric")
    def redis_engine_cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "redisEngineCpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="swapMemoryMetric")
    def swap_memory_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "swapMemoryMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="unusedMemoryMetric")
    def unused_memory_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "unusedMemoryMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="clusterUrl")
    def cluster_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "clusterUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ElastiCacheClusterMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "cluster_type": "clusterType",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_max_evicted_items_count_alarm": "addMaxEvictedItemsCountAlarm",
        "add_max_items_count_alarm": "addMaxItemsCountAlarm",
        "add_max_used_swap_memory_alarm": "addMaxUsedSwapMemoryAlarm",
        "add_min_freeable_memory_alarm": "addMinFreeableMemoryAlarm",
        "add_redis_engine_cpu_usage_alarm": "addRedisEngineCpuUsageAlarm",
    },
)
class ElastiCacheClusterMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        cluster_type: ElastiCacheClusterType,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param cluster_type: (experimental) Cluster type (needed, since each type has their own specific metrics).
        :param add_cpu_usage_alarm: (experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).
        :param add_max_evicted_items_count_alarm: (experimental) Add alarm on number of evicted items.
        :param add_max_items_count_alarm: (experimental) Add alarm on total number of items.
        :param add_max_used_swap_memory_alarm: (experimental) Add alarm on amount of used swap memory.
        :param add_min_freeable_memory_alarm: (experimental) Add alarm on amount of freeable memory.
        :param add_redis_engine_cpu_usage_alarm: (experimental) Add Redis engine CPU usage alarm. It is recommended to monitor CPU utilization with ``addCpuUsageAlarm`` as well for hosts with two vCPUs or less.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfbd4e29efaf5b043591a9a84030fe155e21b5d5c6f02bc54c9f70ea1227c8c5)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_max_evicted_items_count_alarm", value=add_max_evicted_items_count_alarm, expected_type=type_hints["add_max_evicted_items_count_alarm"])
            check_type(argname="argument add_max_items_count_alarm", value=add_max_items_count_alarm, expected_type=type_hints["add_max_items_count_alarm"])
            check_type(argname="argument add_max_used_swap_memory_alarm", value=add_max_used_swap_memory_alarm, expected_type=type_hints["add_max_used_swap_memory_alarm"])
            check_type(argname="argument add_min_freeable_memory_alarm", value=add_min_freeable_memory_alarm, expected_type=type_hints["add_min_freeable_memory_alarm"])
            check_type(argname="argument add_redis_engine_cpu_usage_alarm", value=add_redis_engine_cpu_usage_alarm, expected_type=type_hints["add_redis_engine_cpu_usage_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster_type": cluster_type,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_max_evicted_items_count_alarm is not None:
            self._values["add_max_evicted_items_count_alarm"] = add_max_evicted_items_count_alarm
        if add_max_items_count_alarm is not None:
            self._values["add_max_items_count_alarm"] = add_max_items_count_alarm
        if add_max_used_swap_memory_alarm is not None:
            self._values["add_max_used_swap_memory_alarm"] = add_max_used_swap_memory_alarm
        if add_min_freeable_memory_alarm is not None:
            self._values["add_min_freeable_memory_alarm"] = add_min_freeable_memory_alarm
        if add_redis_engine_cpu_usage_alarm is not None:
            self._values["add_redis_engine_cpu_usage_alarm"] = add_redis_engine_cpu_usage_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def cluster_type(self) -> ElastiCacheClusterType:
        '''(experimental) Cluster type (needed, since each type has their own specific metrics).

        :stability: experimental
        '''
        result = self._values.get("cluster_type")
        assert result is not None, "Required property 'cluster_type' is missing"
        return typing.cast(ElastiCacheClusterType, result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).

        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_evicted_items_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]]:
        '''(experimental) Add alarm on number of evicted items.

        :stability: experimental
        '''
        result = self._values.get("add_max_evicted_items_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]], result)

    @builtins.property
    def add_max_items_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]]:
        '''(experimental) Add alarm on total number of items.

        :stability: experimental
        '''
        result = self._values.get("add_max_items_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]], result)

    @builtins.property
    def add_max_used_swap_memory_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxUsedSwapMemoryThreshold]]:
        '''(experimental) Add alarm on amount of used swap memory.

        :stability: experimental
        '''
        result = self._values.get("add_max_used_swap_memory_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxUsedSwapMemoryThreshold]], result)

    @builtins.property
    def add_min_freeable_memory_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinFreeableMemoryThreshold]]:
        '''(experimental) Add alarm on amount of freeable memory.

        :stability: experimental
        '''
        result = self._values.get("add_min_freeable_memory_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinFreeableMemoryThreshold]], result)

    @builtins.property
    def add_redis_engine_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Add Redis engine CPU usage alarm.

        It is recommended to monitor CPU utilization with ``addCpuUsageAlarm``
        as well for hosts with two vCPUs or less.

        :stability: experimental
        '''
        result = self._values.get("add_redis_engine_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ElastiCacheClusterMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ElastiCacheClusterMonitoringProps",
    jsii_struct_bases=[
        ElastiCacheClusterMetricFactoryProps, ElastiCacheClusterMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster_id": "clusterId",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "cluster_type": "clusterType",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_max_evicted_items_count_alarm": "addMaxEvictedItemsCountAlarm",
        "add_max_items_count_alarm": "addMaxItemsCountAlarm",
        "add_max_used_swap_memory_alarm": "addMaxUsedSwapMemoryAlarm",
        "add_min_freeable_memory_alarm": "addMinFreeableMemoryAlarm",
        "add_redis_engine_cpu_usage_alarm": "addRedisEngineCpuUsageAlarm",
    },
)
class ElastiCacheClusterMonitoringProps(
    ElastiCacheClusterMetricFactoryProps,
    ElastiCacheClusterMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster_id: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        cluster_type: ElastiCacheClusterType,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster_id: (experimental) Cluster to monitor. Default: - monitor all clusters
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param cluster_type: (experimental) Cluster type (needed, since each type has their own specific metrics).
        :param add_cpu_usage_alarm: (experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).
        :param add_max_evicted_items_count_alarm: (experimental) Add alarm on number of evicted items.
        :param add_max_items_count_alarm: (experimental) Add alarm on total number of items.
        :param add_max_used_swap_memory_alarm: (experimental) Add alarm on amount of used swap memory.
        :param add_min_freeable_memory_alarm: (experimental) Add alarm on amount of freeable memory.
        :param add_redis_engine_cpu_usage_alarm: (experimental) Add Redis engine CPU usage alarm. It is recommended to monitor CPU utilization with ``addCpuUsageAlarm`` as well for hosts with two vCPUs or less.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f815c53c9536f7ee998167d2fc7c73449d61c3d85b8f6439555d540e5ed9f91)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_max_evicted_items_count_alarm", value=add_max_evicted_items_count_alarm, expected_type=type_hints["add_max_evicted_items_count_alarm"])
            check_type(argname="argument add_max_items_count_alarm", value=add_max_items_count_alarm, expected_type=type_hints["add_max_items_count_alarm"])
            check_type(argname="argument add_max_used_swap_memory_alarm", value=add_max_used_swap_memory_alarm, expected_type=type_hints["add_max_used_swap_memory_alarm"])
            check_type(argname="argument add_min_freeable_memory_alarm", value=add_min_freeable_memory_alarm, expected_type=type_hints["add_min_freeable_memory_alarm"])
            check_type(argname="argument add_redis_engine_cpu_usage_alarm", value=add_redis_engine_cpu_usage_alarm, expected_type=type_hints["add_redis_engine_cpu_usage_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster_type": cluster_type,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if cluster_id is not None:
            self._values["cluster_id"] = cluster_id
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_max_evicted_items_count_alarm is not None:
            self._values["add_max_evicted_items_count_alarm"] = add_max_evicted_items_count_alarm
        if add_max_items_count_alarm is not None:
            self._values["add_max_items_count_alarm"] = add_max_items_count_alarm
        if add_max_used_swap_memory_alarm is not None:
            self._values["add_max_used_swap_memory_alarm"] = add_max_used_swap_memory_alarm
        if add_min_freeable_memory_alarm is not None:
            self._values["add_min_freeable_memory_alarm"] = add_min_freeable_memory_alarm
        if add_redis_engine_cpu_usage_alarm is not None:
            self._values["add_redis_engine_cpu_usage_alarm"] = add_redis_engine_cpu_usage_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) Cluster to monitor.

        :default: - monitor all clusters

        :stability: experimental
        '''
        result = self._values.get("cluster_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def cluster_type(self) -> ElastiCacheClusterType:
        '''(experimental) Cluster type (needed, since each type has their own specific metrics).

        :stability: experimental
        '''
        result = self._values.get("cluster_type")
        assert result is not None, "Required property 'cluster_type' is missing"
        return typing.cast(ElastiCacheClusterType, result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).

        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_evicted_items_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]]:
        '''(experimental) Add alarm on number of evicted items.

        :stability: experimental
        '''
        result = self._values.get("add_max_evicted_items_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]], result)

    @builtins.property
    def add_max_items_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]]:
        '''(experimental) Add alarm on total number of items.

        :stability: experimental
        '''
        result = self._values.get("add_max_items_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxItemsCountThreshold]], result)

    @builtins.property
    def add_max_used_swap_memory_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxUsedSwapMemoryThreshold]]:
        '''(experimental) Add alarm on amount of used swap memory.

        :stability: experimental
        '''
        result = self._values.get("add_max_used_swap_memory_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxUsedSwapMemoryThreshold]], result)

    @builtins.property
    def add_min_freeable_memory_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinFreeableMemoryThreshold]]:
        '''(experimental) Add alarm on amount of freeable memory.

        :stability: experimental
        '''
        result = self._values.get("add_min_freeable_memory_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinFreeableMemoryThreshold]], result)

    @builtins.property
    def add_redis_engine_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Add Redis engine CPU usage alarm.

        It is recommended to monitor CPU utilization with ``addCpuUsageAlarm``
        as well for hosts with two vCPUs or less.

        :stability: experimental
        '''
        result = self._values.get("add_redis_engine_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ElastiCacheClusterMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IAlarmDedupeStringProcessor)
class ExtendDedupeString(
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.ExtendDedupeString",
):
    '''(experimental) Dedupe string processor that adds prefix and/or suffix to the dedupe string.

    :stability: experimental
    '''

    def __init__(
        self,
        prefix: typing.Optional[builtins.str] = None,
        suffix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param prefix: -
        :param suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__503cb2d7fecf37d79e0e391064880a51e83b28fa6a5cc83dd22615ea7abe8753)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument suffix", value=suffix, expected_type=type_hints["suffix"])
        jsii.create(self.__class__, self, [prefix, suffix])

    @jsii.member(jsii_name="processDedupeString")
    def process_dedupe_string(self, dedupe_string: builtins.str) -> builtins.str:
        '''(experimental) Process the dedupe string which was auto-generated.

        :param dedupe_string: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b004d96b7986782b01647f31857f1f29474db5ba57d6592d9c439517f91f464d)
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
        return typing.cast(builtins.str, jsii.invoke(self, "processDedupeString", [dedupe_string]))

    @jsii.member(jsii_name="processDedupeStringOverride")
    def process_dedupe_string_override(
        self,
        dedupe_string: builtins.str,
    ) -> builtins.str:
        '''(experimental) Process the dedupe string which was specified by the user as an override.

        :param dedupe_string: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84caa32355b3aea9ba7415e2dc0b420c4f6b6907c04efb4d65a28696cdba7f2d)
            check_type(argname="argument dedupe_string", value=dedupe_string, expected_type=type_hints["dedupe_string"])
        return typing.cast(builtins.str, jsii.invoke(self, "processDedupeStringOverride", [dedupe_string]))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FargateApplicationLoadBalancerMonitoringProps",
    jsii_struct_bases=[
        ApplicationLoadBalancerMetricFactoryProps,
        BaseMonitoringProps,
        BaseFargateServiceAlarms,
    ],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "application_load_balancer": "applicationLoadBalancer",
        "application_target_group": "applicationTargetGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "fargate_service": "fargateService",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class FargateApplicationLoadBalancerMonitoringProps(
    ApplicationLoadBalancerMetricFactoryProps,
    BaseMonitoringProps,
    BaseFargateServiceAlarms,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for Fargate service with application load balancer and plain service.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param application_load_balancer: 
        :param application_target_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb2989da27c15f643e02a55c18e814ae8000f0dc46c81c4c965ba97915aee107)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument application_load_balancer", value=application_load_balancer, expected_type=type_hints["application_load_balancer"])
            check_type(argname="argument application_target_group", value=application_target_group, expected_type=type_hints["application_target_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application_load_balancer": application_load_balancer,
            "application_target_group": application_target_group,
            "fargate_service": fargate_service,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def application_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_load_balancer")
        assert result is not None, "Required property 'application_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, result)

    @builtins.property
    def application_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("application_target_group")
        assert result is not None, "Required property 'application_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fargate_service(self) -> _aws_cdk_aws_ecs_ceddda9d.FargateService:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.FargateService, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FargateApplicationLoadBalancerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FargateNetworkLoadBalancerMonitoringProps",
    jsii_struct_bases=[
        NetworkLoadBalancerMetricFactoryProps,
        BaseMonitoringProps,
        BaseFargateServiceAlarms,
    ],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "network_load_balancer": "networkLoadBalancer",
        "network_target_group": "networkTargetGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "fargate_service": "fargateService",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class FargateNetworkLoadBalancerMonitoringProps(
    NetworkLoadBalancerMetricFactoryProps,
    BaseMonitoringProps,
    BaseFargateServiceAlarms,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for Fargate service with network load balancer and plain service.

        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param network_load_balancer: 
        :param network_target_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9f8c5228a815ec10ec36ed64111406948e5fc9e7bb1f17303e17877f1ea0f185)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument network_load_balancer", value=network_load_balancer, expected_type=type_hints["network_load_balancer"])
            check_type(argname="argument network_target_group", value=network_target_group, expected_type=type_hints["network_target_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_load_balancer": network_load_balancer,
            "network_target_group": network_target_group,
            "fargate_service": fargate_service,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_load_balancer")
        assert result is not None, "Required property 'network_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer, result)

    @builtins.property
    def network_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_target_group")
        assert result is not None, "Required property 'network_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fargate_service(self) -> _aws_cdk_aws_ecs_ceddda9d.FargateService:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.FargateService, result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FargateNetworkLoadBalancerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class FargateServiceMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.FargateServiceMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
        target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param load_balancer: 
        :param target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9328f631880ce247f60e2e6a197fd139b3de4938d0ef96d0255e0363790b725)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = CustomFargateServiceMonitoringProps(
            fargate_service=fargate_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            load_balancer=load_balancer,
            target_group=target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createCpuWidget")
    def create_cpu_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cbc430df27e0ab56b683a9919c3c7f89da1070d99094edec9d462ce805445cb2)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCpuWidget", [width, height]))

    @jsii.member(jsii_name="createMemoryWidget")
    def create_memory_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b18db518cc36809964075a36fb691846e5c1f6b9793df537ee170827d0c631f)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createMemoryWidget", [width, height]))

    @jsii.member(jsii_name="createTaskHealthWidget")
    def create_task_health_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42999028838d6f3a4c03901f33eed189d89ea3f0371ba7d93fbf1acd11e03350)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTaskHealthWidget", [width, height]))

    @jsii.member(jsii_name="createTcpFlowsWidget")
    def create_tcp_flows_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3ce55186d97ff139349bad2daa672144ddbb72dfddb9abbcdb20e70ae8c920a7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTcpFlowsWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpcFlowsWidget")
    def create_tpc_flows_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :deprecated: use {

        :see: createTcpFlowsWidget} instead.
        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d414135d2047fe641b5df246bc947fc593dbfd55b0807b6587a043b139b676b)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpcFlowsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="baseServiceMetricFactory")
    def base_service_metric_factory(self) -> BaseServiceMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(BaseServiceMetricFactory, jsii.get(self, "baseServiceMetricFactory"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageAnnotations")
    def cpu_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "cpuUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="cpuUtilisationMetric")
    def cpu_utilisation_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUtilisationMetric"))

    @builtins.property
    @jsii.member(jsii_name="ephemeralStorageUsageMetric")
    def ephemeral_storage_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "ephemeralStorageUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="memoryUsageAnnotations")
    def memory_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "memoryUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="memoryUtilisationMetric")
    def memory_utilisation_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "memoryUtilisationMetric"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def metric_factory(self) -> MetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(MetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesAnnotations")
    def processed_bytes_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "processedBytesAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="runningTaskCountMetric")
    def running_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "runningTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAlarmFactory")
    def task_health_alarm_factory(self) -> TaskHealthAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TaskHealthAlarmFactory, jsii.get(self, "taskHealthAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAnnotations")
    def task_health_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "taskHealthAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="throughputAlarmFactory")
    def throughput_alarm_factory(self) -> ThroughputAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ThroughputAlarmFactory, jsii.get(self, "throughputAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="activeTcpFlowCountMetric")
    def active_tcp_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "activeTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskCountMetric")
    def healthy_task_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "healthyTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="healthyTaskPercentMetric")
    def healthy_task_percent_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "healthyTaskPercentMetric"))

    @builtins.property
    @jsii.member(jsii_name="loadBalancerMetricFactory")
    def load_balancer_metric_factory(
        self,
    ) -> typing.Optional[ILoadBalancerMetricFactory]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[ILoadBalancerMetricFactory], jsii.get(self, "loadBalancerMetricFactory"))

    @builtins.property
    @jsii.member(jsii_name="newTcpFlowCountMetric")
    def new_tcp_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "newTcpFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="processedBytesMetric")
    def processed_bytes_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "processedBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyRoutingFlowCountMetric")
    def unhealthy_routing_flow_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "unhealthyRoutingFlowCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="unhealthyTaskCountMetric")
    def unhealthy_task_count_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "unhealthyTaskCountMetric"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FargateServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseFargateServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "fargate_service": "fargateService",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
        "invert_load_balancer_task_count_metrics_statistics": "invertLoadBalancerTaskCountMetricsStatistics",
    },
)
class FargateServiceMonitoringProps(BaseMonitoringProps, BaseFargateServiceAlarms):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        fargate_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedFargateService, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedFargateService],
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Monitoring props for load-balanced Fargate service.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__70264c750ed57fe982c43247ea46fa41074bdffe16f85e72ef0a343f3f2a22d7)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
            check_type(argname="argument invert_load_balancer_task_count_metrics_statistics", value=invert_load_balancer_task_count_metrics_statistics, expected_type=type_hints["invert_load_balancer_task_count_metrics_statistics"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "fargate_service": fargate_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm
        if invert_load_balancer_task_count_metrics_statistics is not None:
            self._values["invert_load_balancer_task_count_metrics_statistics"] = invert_load_balancer_task_count_metrics_statistics

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fargate_service(
        self,
    ) -> typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedFargateService, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedFargateService]:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedFargateService, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedFargateService], result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    @builtins.property
    def invert_load_balancer_task_count_metrics_statistics(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_load_balancer_task_count_metrics_statistics")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FargateServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IAlarmAnnotationStrategy)
class FillingAlarmAnnotationStrategy(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="cdk-monitoring-constructs.FillingAlarmAnnotationStrategy",
):
    '''(experimental) Annotation strategy that fills the annotation provided, using the input and user requirements.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="createAnnotation")
    def create_annotation(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''(experimental) Creates annotation based on the metric and alarm properties.

        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, jsii.invoke(self, "createAnnotation", [props]))

    @jsii.member(jsii_name="createAnnotationToFill")
    @abc.abstractmethod
    def _create_annotation_to_fill(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="getAlarmingRangeShade")
    def _get_alarming_range_shade(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Shading]:
        '''
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Shading], jsii.invoke(self, "getAlarmingRangeShade", [props]))


class _FillingAlarmAnnotationStrategyProxy(FillingAlarmAnnotationStrategy):
    @jsii.member(jsii_name="createAnnotationToFill")
    def _create_annotation_to_fill(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, jsii.invoke(self, "createAnnotationToFill", [props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, FillingAlarmAnnotationStrategy).__jsii_proxy_class__ = lambda : _FillingAlarmAnnotationStrategyProxy


class FluentBitMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.FluentBitMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
        create_optional_metric_filters: typing.Optional[builtins.bool] = None,
        namespace: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param log_group: (experimental) Log group that contains FluentBit metric logs.
        :param create_optional_metric_filters: (experimental) Metrics for input bytes total, output bytes total and output records total are not shown on default dashboard. If you want to get MetricFilters created to have those metrics present in CloudWatch set this flag to true Default: false
        :param namespace: (experimental) Namespace that metrics will be emitted to. Default: metric factory default
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a628c56b07e7792ecbcabae31115f1b74ec51b35ff7c645568bb65b679e87170)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = FluentBitMonitoringProps(
            log_group=log_group,
            create_optional_metric_filters=create_optional_metric_filters,
            namespace=namespace,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="filterMetrics")
    def _filter_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.get(self, "filterMetrics"))

    @builtins.property
    @jsii.member(jsii_name="inputMetrics")
    def _input_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.get(self, "inputMetrics"))

    @builtins.property
    @jsii.member(jsii_name="logGroupName")
    def _log_group_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "logGroupName"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def _metric_factory(self) -> FluentBitMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(FluentBitMetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="outputMetrics")
    def _output_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.get(self, "outputMetrics"))

    @builtins.property
    @jsii.member(jsii_name="storageMetrics")
    def _storage_metrics(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.Metric], jsii.get(self, "storageMetrics"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.FluentBitMonitoringProps",
    jsii_struct_bases=[FluentBitMetricFactoryProps, BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "namespace": "namespace",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "log_group": "logGroup",
        "create_optional_metric_filters": "createOptionalMetricFilters",
    },
)
class FluentBitMonitoringProps(FluentBitMetricFactoryProps, BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        namespace: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
        create_optional_metric_filters: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param namespace: (experimental) Namespace that metrics will be emitted to. Default: metric factory default
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param log_group: (experimental) Log group that contains FluentBit metric logs.
        :param create_optional_metric_filters: (experimental) Metrics for input bytes total, output bytes total and output records total are not shown on default dashboard. If you want to get MetricFilters created to have those metrics present in CloudWatch set this flag to true Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b19f477d9fddcfe96bc4dd0efc7509bb085f94e0fc202a7fb4d4994b881cbc7b)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            check_type(argname="argument create_optional_metric_filters", value=create_optional_metric_filters, expected_type=type_hints["create_optional_metric_filters"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "log_group": log_group,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if namespace is not None:
            self._values["namespace"] = namespace
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if create_optional_metric_filters is not None:
            self._values["create_optional_metric_filters"] = create_optional_metric_filters

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Namespace that metrics will be emitted to.

        :default: metric factory default

        :stability: experimental
        '''
        result = self._values.get("namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def log_group(self) -> _aws_cdk_aws_logs_ceddda9d.ILogGroup:
        '''(experimental) Log group that contains FluentBit metric logs.

        :stability: experimental
        '''
        result = self._values.get("log_group")
        assert result is not None, "Required property 'log_group' is missing"
        return typing.cast(_aws_cdk_aws_logs_ceddda9d.ILogGroup, result)

    @builtins.property
    def create_optional_metric_filters(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Metrics for input bytes total, output bytes total and output records total are not shown on default dashboard.

        If you want to get MetricFilters created to have those metrics present in CloudWatch set this flag to true

        :default: false

        :stability: experimental
        '''
        result = self._values.get("create_optional_metric_filters")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FluentBitMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class GlueJobMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.GlueJobMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        job_name: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_failed_task_count_alarm: 
        :param add_failed_task_rate_alarm: 
        :param add_killed_task_count_alarm: 
        :param add_killed_task_rate_alarm: 
        :param job_name: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22b0f474d6af396419dde83af6e523fcd4a49682d6ca80672e6fe7953f7fdec6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = GlueJobMonitoringProps(
            add_failed_task_count_alarm=add_failed_task_count_alarm,
            add_failed_task_rate_alarm=add_failed_task_rate_alarm,
            add_killed_task_count_alarm=add_killed_task_count_alarm,
            add_killed_task_rate_alarm=add_killed_task_rate_alarm,
            job_name=job_name,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createDataMovementWidget")
    def create_data_movement_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd0a807f9138865ab1ec2bf34e06444f9b935a310caad8ed546fb5474a6c47ab)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDataMovementWidget", [width, height]))

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__41fae5d326661559ffe0f82198a25b474138fac35c5df7279fcd193389d05bc7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ac2bab02fb4b55d7188ed3e7dcfa2dc91e10cb5a5c845bac06c936116be12fd4)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createJobExecutionWidget")
    def create_job_execution_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c1df77e83a37db6e26f77fa046ecdbc2152a4a3dd90aa202ec73abe891e6015)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createJobExecutionWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createUtilizationWidget")
    def create_utilization_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e863a603953382a8c09680cf582cc5ce04df48c58f19d6046e74415d1329045f)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createUtilizationWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="activeExecutorsMetric")
    def active_executors_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "activeExecutorsMetric"))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="bytesReadFromS3Metric")
    def bytes_read_from_s3_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "bytesReadFromS3Metric"))

    @builtins.property
    @jsii.member(jsii_name="bytesWrittenToS3Metric")
    def bytes_written_to_s3_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "bytesWrittenToS3Metric"))

    @builtins.property
    @jsii.member(jsii_name="completedStagesMetric")
    def completed_stages_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "completedStagesMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuUsageMetric")
    def cpu_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="failedTaskCountMetric")
    def failed_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="failedTaskRateMetric")
    def failed_task_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedTaskRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="heapMemoryUsageMetric")
    def heap_memory_usage_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "heapMemoryUsageMetric"))

    @builtins.property
    @jsii.member(jsii_name="killedTaskCountMetric")
    def killed_task_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "killedTaskCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="killedTaskRateMetric")
    def killed_task_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "killedTaskRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="neededExecutorsMetric")
    def needed_executors_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "neededExecutorsMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.GlueJobMonitoringOptions",
    jsii_struct_bases=[GlueJobMetricFactoryProps, BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "job_name": "jobName",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_failed_task_count_alarm": "addFailedTaskCountAlarm",
        "add_failed_task_rate_alarm": "addFailedTaskRateAlarm",
        "add_killed_task_count_alarm": "addKilledTaskCountAlarm",
        "add_killed_task_rate_alarm": "addKilledTaskRateAlarm",
    },
)
class GlueJobMonitoringOptions(GlueJobMetricFactoryProps, BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        job_name: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param job_name: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_failed_task_count_alarm: 
        :param add_failed_task_rate_alarm: 
        :param add_killed_task_count_alarm: 
        :param add_killed_task_rate_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd9bbe491a1aa388910943cc1423845ad816717802f10d327bf1df10d645fee7)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_failed_task_count_alarm", value=add_failed_task_count_alarm, expected_type=type_hints["add_failed_task_count_alarm"])
            check_type(argname="argument add_failed_task_rate_alarm", value=add_failed_task_rate_alarm, expected_type=type_hints["add_failed_task_rate_alarm"])
            check_type(argname="argument add_killed_task_count_alarm", value=add_killed_task_count_alarm, expected_type=type_hints["add_killed_task_count_alarm"])
            check_type(argname="argument add_killed_task_rate_alarm", value=add_killed_task_rate_alarm, expected_type=type_hints["add_killed_task_rate_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "job_name": job_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_failed_task_count_alarm is not None:
            self._values["add_failed_task_count_alarm"] = add_failed_task_count_alarm
        if add_failed_task_rate_alarm is not None:
            self._values["add_failed_task_rate_alarm"] = add_failed_task_rate_alarm
        if add_killed_task_count_alarm is not None:
            self._values["add_killed_task_count_alarm"] = add_killed_task_count_alarm
        if add_killed_task_rate_alarm is not None:
            self._values["add_killed_task_rate_alarm"] = add_killed_task_rate_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("job_name")
        assert result is not None, "Required property 'job_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_failed_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_task_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_task_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_killed_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_killed_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_killed_task_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_killed_task_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GlueJobMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.GlueJobMonitoringProps",
    jsii_struct_bases=[GlueJobMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "job_name": "jobName",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_failed_task_count_alarm": "addFailedTaskCountAlarm",
        "add_failed_task_rate_alarm": "addFailedTaskRateAlarm",
        "add_killed_task_count_alarm": "addKilledTaskCountAlarm",
        "add_killed_task_rate_alarm": "addKilledTaskRateAlarm",
    },
)
class GlueJobMonitoringProps(GlueJobMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        job_name: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param job_name: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_failed_task_count_alarm: 
        :param add_failed_task_rate_alarm: 
        :param add_killed_task_count_alarm: 
        :param add_killed_task_rate_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__085e1f2eb07133096bad6508941ad5e65f45433816d71580d4ba753f435fa8e4)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument job_name", value=job_name, expected_type=type_hints["job_name"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_failed_task_count_alarm", value=add_failed_task_count_alarm, expected_type=type_hints["add_failed_task_count_alarm"])
            check_type(argname="argument add_failed_task_rate_alarm", value=add_failed_task_rate_alarm, expected_type=type_hints["add_failed_task_rate_alarm"])
            check_type(argname="argument add_killed_task_count_alarm", value=add_killed_task_count_alarm, expected_type=type_hints["add_killed_task_count_alarm"])
            check_type(argname="argument add_killed_task_rate_alarm", value=add_killed_task_rate_alarm, expected_type=type_hints["add_killed_task_rate_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "job_name": job_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_failed_task_count_alarm is not None:
            self._values["add_failed_task_count_alarm"] = add_failed_task_count_alarm
        if add_failed_task_rate_alarm is not None:
            self._values["add_failed_task_rate_alarm"] = add_failed_task_rate_alarm
        if add_killed_task_count_alarm is not None:
            self._values["add_killed_task_count_alarm"] = add_killed_task_count_alarm
        if add_killed_task_rate_alarm is not None:
            self._values["add_killed_task_rate_alarm"] = add_killed_task_rate_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def job_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("job_name")
        assert result is not None, "Required property 'job_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_failed_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_task_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_task_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_killed_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_killed_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_killed_task_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_killed_task_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GlueJobMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class KinesisDataAnalyticsMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        application: builtins.str,
        add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param application: 
        :param add_downtime_alarm: 
        :param add_full_restart_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38a7d1b577cd82fa4c9a2054f49bca41d9f2057d3b6e7a6d3d32c987103744f3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = KinesisDataAnalyticsMonitoringProps(
            application=application,
            add_downtime_alarm=add_downtime_alarm,
            add_full_restart_count_alarm=add_full_restart_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createDownTimeWidget")
    def create_down_time_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__635e48cbc71ff5a20252794f78f1c18a14e09a55fb035971572e04ae0a2b6c8e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createDownTimeWidget", [width, height]))

    @jsii.member(jsii_name="createFullRestartsWidget")
    def create_full_restarts_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57ab2336f9d3946acd405fe3b3aee080ca187d98e7fd930df202b24d8bae64c7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createFullRestartsWidget", [width, height]))

    @jsii.member(jsii_name="createGarbageCollectionWidget")
    def create_garbage_collection_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1a33824c4aebc05fdedf787039987acfa88e89bcb678fb0489384c757619684)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createGarbageCollectionWidget", [width, height]))

    @jsii.member(jsii_name="createKPUWidget")
    def create_kpu_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45f2e91edff5f1c19ec66b859666ed785d6d02bb67185ee03c85ad40769c92d5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createKPUWidget", [width, height]))

    @jsii.member(jsii_name="createLastCheckpointDurationWidget")
    def create_last_checkpoint_duration_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03e959a14341ec179c94521dd1010120f7f06900a496ed19685b36541de419a3)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLastCheckpointDurationWidget", [width, height]))

    @jsii.member(jsii_name="createLastCheckpointSizeWidget")
    def create_last_checkpoint_size_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7731af01a0176130da7f2a4a6decbb0f62cfe6ca20deb2ce36afc5b0d1c4d71e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLastCheckpointSizeWidget", [width, height]))

    @jsii.member(jsii_name="createNumberOfFailedCheckpointsWidget")
    def create_number_of_failed_checkpoints_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b45d64eeeffa382742cd9cc3bb17f7f9f8cf8e335b51b07ddb41cc5c39cb9d2e)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createNumberOfFailedCheckpointsWidget", [width, height]))

    @jsii.member(jsii_name="createResourceUtilizationWidget")
    def create_resource_utilization_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0b224cff688f3c07347d6cdc1bb9b45868b12e698039442af904c976a12d345a)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createResourceUtilizationWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="cpuUtilizationPercentMetric")
    def cpu_utilization_percent_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "cpuUtilizationPercentMetric"))

    @builtins.property
    @jsii.member(jsii_name="downtimeAnnotations")
    def downtime_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "downtimeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="downtimeMsMetric")
    def downtime_ms_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "downtimeMsMetric"))

    @builtins.property
    @jsii.member(jsii_name="fullRestartAnnotations")
    def full_restart_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "fullRestartAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="fullRestartsCountMetric")
    def full_restarts_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "fullRestartsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="heapMemoryUtilizationPercentMetric")
    def heap_memory_utilization_percent_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "heapMemoryUtilizationPercentMetric"))

    @builtins.property
    @jsii.member(jsii_name="kdaAlarmFactory")
    def kda_alarm_factory(self) -> KinesisDataAnalyticsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(KinesisDataAnalyticsAlarmFactory, jsii.get(self, "kdaAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="kpusCountMetric")
    def kpus_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "kpusCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="lastCheckpointDurationMsMetric")
    def last_checkpoint_duration_ms_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "lastCheckpointDurationMsMetric"))

    @builtins.property
    @jsii.member(jsii_name="lastCheckpointSizeBytesMetric")
    def last_checkpoint_size_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "lastCheckpointSizeBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="numberOfFailedCheckpointsCountMetric")
    def number_of_failed_checkpoints_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "numberOfFailedCheckpointsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="oldGenerationGCCountMetric")
    def old_generation_gc_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "oldGenerationGCCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="oldGenerationGCTimeMsMetric")
    def old_generation_gc_time_ms_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "oldGenerationGCTimeMsMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="kinesisDataAnalyticsUrl")
    def kinesis_data_analytics_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "kinesisDataAnalyticsUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_downtime_alarm": "addDowntimeAlarm",
        "add_full_restart_count_alarm": "addFullRestartCountAlarm",
    },
)
class KinesisDataAnalyticsMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_downtime_alarm: 
        :param add_full_restart_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51cb8da315986734fdabf244c79462739bab30bee71cf81f4a8b0161c0f94966)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_downtime_alarm", value=add_downtime_alarm, expected_type=type_hints["add_downtime_alarm"])
            check_type(argname="argument add_full_restart_count_alarm", value=add_full_restart_count_alarm, expected_type=type_hints["add_full_restart_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_downtime_alarm is not None:
            self._values["add_downtime_alarm"] = add_downtime_alarm
        if add_full_restart_count_alarm is not None:
            self._values["add_full_restart_count_alarm"] = add_full_restart_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_downtime_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxDowntimeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_downtime_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxDowntimeThreshold]], result)

    @builtins.property
    def add_full_restart_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FullRestartCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_full_restart_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FullRestartCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataAnalyticsMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataAnalyticsMonitoringProps",
    jsii_struct_bases=[
        KinesisDataAnalyticsMetricFactoryProps, KinesisDataAnalyticsMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "application": "application",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_downtime_alarm": "addDowntimeAlarm",
        "add_full_restart_count_alarm": "addFullRestartCountAlarm",
    },
)
class KinesisDataAnalyticsMonitoringProps(
    KinesisDataAnalyticsMetricFactoryProps,
    KinesisDataAnalyticsMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        application: builtins.str,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param application: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_downtime_alarm: 
        :param add_full_restart_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__75ff1f1c6e14943be636c413fdc1fea473b93121aa20fcc0da022a59914f76ec)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument application", value=application, expected_type=type_hints["application"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_downtime_alarm", value=add_downtime_alarm, expected_type=type_hints["add_downtime_alarm"])
            check_type(argname="argument add_full_restart_count_alarm", value=add_full_restart_count_alarm, expected_type=type_hints["add_full_restart_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application": application,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_downtime_alarm is not None:
            self._values["add_downtime_alarm"] = add_downtime_alarm
        if add_full_restart_count_alarm is not None:
            self._values["add_full_restart_count_alarm"] = add_full_restart_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def application(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("application")
        assert result is not None, "Required property 'application' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_downtime_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxDowntimeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_downtime_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxDowntimeThreshold]], result)

    @builtins.property
    def add_full_restart_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FullRestartCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_full_restart_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FullRestartCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataAnalyticsMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class KinesisDataStreamMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisDataStreamMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        stream_name: builtins.str,
        add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param stream_name: 
        :param add_iterator_max_age_alarm: 
        :param add_put_records_failed_alarm: 
        :param add_put_records_throttled_alarm: 
        :param add_read_provisioned_throughput_exceeded_alarm: 
        :param add_throttled_records_alarm: 
        :param add_write_provisioned_throughput_exceeded_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0dea745df641dddbf9a3ec2331d33999a9e8c4bf55bf22960dee4f411422c20)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = KinesisDataStreamMonitoringProps(
            stream_name=stream_name,
            add_iterator_max_age_alarm=add_iterator_max_age_alarm,
            add_put_records_failed_alarm=add_put_records_failed_alarm,
            add_put_records_throttled_alarm=add_put_records_throttled_alarm,
            add_read_provisioned_throughput_exceeded_alarm=add_read_provisioned_throughput_exceeded_alarm,
            add_throttled_records_alarm=add_throttled_records_alarm,
            add_write_provisioned_throughput_exceeded_alarm=add_write_provisioned_throughput_exceeded_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createCapacityWidget")
    def create_capacity_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__15675bdfea52113be935ed1beaef26b54e7e5d182253a819b09c6d2f5dfbd3b4)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createCapacityWidget", [width, height]))

    @jsii.member(jsii_name="createIncomingDataWidget")
    def create_incoming_data_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e5942ad4d15da6b8776f9df4c73768d892b15de19824856d742b199a142bb15)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createIncomingDataWidget", [width, height]))

    @jsii.member(jsii_name="createIteratorAgeWidget")
    def create_iterator_age_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b508ce33db14b1bd73f6b1a17db170b15fcd41a94c9847a75e4dc7de83e7c124)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createIteratorAgeWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a4ccac305f273ce99ceff1c575ef5e2ac8793c3a6aea5c42b28aca02dadb51aa)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createOperationWidget")
    def create_operation_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd33f6aaaf491b0fd170cd6bc587eb49bc5d42283dcc6a0a7ebdb158711a5fa8)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createOperationWidget", [width, height]))

    @jsii.member(jsii_name="createRecordNumberWidget")
    def create_record_number_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd11ef78ec316426495da7edada56d1ccc0291d5442d80ff45f8bf1ba3c84bc1)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createRecordNumberWidget", [width, height]))

    @jsii.member(jsii_name="createRecordSizeWidget")
    def create_record_size_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5344ae1011115612104a1c26097b60bb0b8b1bf3a27b9a1de75ab86cf3250e53)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createRecordSizeWidget", [width, height]))

    @jsii.member(jsii_name="createSecondAdditionalRow")
    def create_second_additional_row(self) -> _aws_cdk_aws_cloudwatch_ceddda9d.Row:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.Row, jsii.invoke(self, "createSecondAdditionalRow", []))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="ageAnnotations")
    def age_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "ageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="incomingDataSumBytesMetric")
    def incoming_data_sum_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingDataSumBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="incomingDataSumCountMetric")
    def incoming_data_sum_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingDataSumCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="kinesisAlarmFactory")
    def kinesis_alarm_factory(self) -> KinesisAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(KinesisAlarmFactory, jsii.get(self, "kinesisAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="metricGetRecordsIteratorAge")
    def metric_get_records_iterator_age(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "metricGetRecordsIteratorAge"))

    @builtins.property
    @jsii.member(jsii_name="metricGetRecordsLatencyAverage")
    def metric_get_records_latency_average(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "metricGetRecordsLatencyAverage"))

    @builtins.property
    @jsii.member(jsii_name="metricGetRecordsSuccessCount")
    def metric_get_records_success_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "metricGetRecordsSuccessCount"))

    @builtins.property
    @jsii.member(jsii_name="metricGetRecordsSumCount")
    def metric_get_records_sum_count(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "metricGetRecordsSumCount"))

    @builtins.property
    @jsii.member(jsii_name="metricGetRecordSumBytes")
    def metric_get_record_sum_bytes(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "metricGetRecordSumBytes"))

    @builtins.property
    @jsii.member(jsii_name="provisionedCapacityAnnotations")
    def provisioned_capacity_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "provisionedCapacityAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="putRecordLatencyAverageMetric")
    def put_record_latency_average_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordLatencyAverageMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsFailedRecordsCountMetric")
    def put_records_failed_records_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsFailedRecordsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsLatencyAverageMetric")
    def put_records_latency_average_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsLatencyAverageMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsSuccessCountMetric")
    def put_records_success_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsSuccessCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsSuccessfulRecordsCountMetric")
    def put_records_successful_records_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsSuccessfulRecordsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsSumBytesMetric")
    def put_records_sum_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsSumBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsThrottledRecordsCountMetric")
    def put_records_throttled_records_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsThrottledRecordsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordsTotalRecordsCountMetric")
    def put_records_total_records_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordsTotalRecordsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordSuccessCountMetric")
    def put_record_success_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordSuccessCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="putRecordSumBytesMetric")
    def put_record_sum_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordSumBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="readProvisionedThroughputExceededMetric")
    def read_provisioned_throughput_exceeded_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "readProvisionedThroughputExceededMetric"))

    @builtins.property
    @jsii.member(jsii_name="recordCountAnnotations")
    def record_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "recordCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="writeProvisionedThroughputExceededMetric")
    def write_provisioned_throughput_exceeded_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "writeProvisionedThroughputExceededMetric"))

    @builtins.property
    @jsii.member(jsii_name="streamUrl")
    def stream_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "streamUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataStreamMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_iterator_max_age_alarm": "addIteratorMaxAgeAlarm",
        "add_put_records_failed_alarm": "addPutRecordsFailedAlarm",
        "add_put_records_throttled_alarm": "addPutRecordsThrottledAlarm",
        "add_read_provisioned_throughput_exceeded_alarm": "addReadProvisionedThroughputExceededAlarm",
        "add_throttled_records_alarm": "addThrottledRecordsAlarm",
        "add_write_provisioned_throughput_exceeded_alarm": "addWriteProvisionedThroughputExceededAlarm",
    },
)
class KinesisDataStreamMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_iterator_max_age_alarm: 
        :param add_put_records_failed_alarm: 
        :param add_put_records_throttled_alarm: 
        :param add_read_provisioned_throughput_exceeded_alarm: 
        :param add_throttled_records_alarm: 
        :param add_write_provisioned_throughput_exceeded_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d416de5c6206b97c3384d0ed8ac710b02485550260739a903556dede7a95062)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_iterator_max_age_alarm", value=add_iterator_max_age_alarm, expected_type=type_hints["add_iterator_max_age_alarm"])
            check_type(argname="argument add_put_records_failed_alarm", value=add_put_records_failed_alarm, expected_type=type_hints["add_put_records_failed_alarm"])
            check_type(argname="argument add_put_records_throttled_alarm", value=add_put_records_throttled_alarm, expected_type=type_hints["add_put_records_throttled_alarm"])
            check_type(argname="argument add_read_provisioned_throughput_exceeded_alarm", value=add_read_provisioned_throughput_exceeded_alarm, expected_type=type_hints["add_read_provisioned_throughput_exceeded_alarm"])
            check_type(argname="argument add_throttled_records_alarm", value=add_throttled_records_alarm, expected_type=type_hints["add_throttled_records_alarm"])
            check_type(argname="argument add_write_provisioned_throughput_exceeded_alarm", value=add_write_provisioned_throughput_exceeded_alarm, expected_type=type_hints["add_write_provisioned_throughput_exceeded_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_iterator_max_age_alarm is not None:
            self._values["add_iterator_max_age_alarm"] = add_iterator_max_age_alarm
        if add_put_records_failed_alarm is not None:
            self._values["add_put_records_failed_alarm"] = add_put_records_failed_alarm
        if add_put_records_throttled_alarm is not None:
            self._values["add_put_records_throttled_alarm"] = add_put_records_throttled_alarm
        if add_read_provisioned_throughput_exceeded_alarm is not None:
            self._values["add_read_provisioned_throughput_exceeded_alarm"] = add_read_provisioned_throughput_exceeded_alarm
        if add_throttled_records_alarm is not None:
            self._values["add_throttled_records_alarm"] = add_throttled_records_alarm
        if add_write_provisioned_throughput_exceeded_alarm is not None:
            self._values["add_write_provisioned_throughput_exceeded_alarm"] = add_write_provisioned_throughput_exceeded_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_iterator_max_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIteratorAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_iterator_max_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIteratorAgeThreshold]], result)

    @builtins.property
    def add_put_records_failed_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsFailedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_put_records_failed_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsFailedThreshold]], result)

    @builtins.property
    def add_put_records_throttled_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_put_records_throttled_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_read_provisioned_throughput_exceeded_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_read_provisioned_throughput_exceeded_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_throttled_records_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttled_records_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_write_provisioned_throughput_exceeded_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_write_provisioned_throughput_exceeded_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataStreamMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisDataStreamMonitoringProps",
    jsii_struct_bases=[
        KinesisDataStreamMetricFactoryProps, KinesisDataStreamMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "stream_name": "streamName",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_iterator_max_age_alarm": "addIteratorMaxAgeAlarm",
        "add_put_records_failed_alarm": "addPutRecordsFailedAlarm",
        "add_put_records_throttled_alarm": "addPutRecordsThrottledAlarm",
        "add_read_provisioned_throughput_exceeded_alarm": "addReadProvisionedThroughputExceededAlarm",
        "add_throttled_records_alarm": "addThrottledRecordsAlarm",
        "add_write_provisioned_throughput_exceeded_alarm": "addWriteProvisionedThroughputExceededAlarm",
    },
)
class KinesisDataStreamMonitoringProps(
    KinesisDataStreamMetricFactoryProps,
    KinesisDataStreamMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        stream_name: builtins.str,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param stream_name: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_iterator_max_age_alarm: 
        :param add_put_records_failed_alarm: 
        :param add_put_records_throttled_alarm: 
        :param add_read_provisioned_throughput_exceeded_alarm: 
        :param add_throttled_records_alarm: 
        :param add_write_provisioned_throughput_exceeded_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25cba1ee4f7ed53338ba97d1b8d2a97ca2dfa0c36613c28201b520938ca6dab6)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument stream_name", value=stream_name, expected_type=type_hints["stream_name"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_iterator_max_age_alarm", value=add_iterator_max_age_alarm, expected_type=type_hints["add_iterator_max_age_alarm"])
            check_type(argname="argument add_put_records_failed_alarm", value=add_put_records_failed_alarm, expected_type=type_hints["add_put_records_failed_alarm"])
            check_type(argname="argument add_put_records_throttled_alarm", value=add_put_records_throttled_alarm, expected_type=type_hints["add_put_records_throttled_alarm"])
            check_type(argname="argument add_read_provisioned_throughput_exceeded_alarm", value=add_read_provisioned_throughput_exceeded_alarm, expected_type=type_hints["add_read_provisioned_throughput_exceeded_alarm"])
            check_type(argname="argument add_throttled_records_alarm", value=add_throttled_records_alarm, expected_type=type_hints["add_throttled_records_alarm"])
            check_type(argname="argument add_write_provisioned_throughput_exceeded_alarm", value=add_write_provisioned_throughput_exceeded_alarm, expected_type=type_hints["add_write_provisioned_throughput_exceeded_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "stream_name": stream_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_iterator_max_age_alarm is not None:
            self._values["add_iterator_max_age_alarm"] = add_iterator_max_age_alarm
        if add_put_records_failed_alarm is not None:
            self._values["add_put_records_failed_alarm"] = add_put_records_failed_alarm
        if add_put_records_throttled_alarm is not None:
            self._values["add_put_records_throttled_alarm"] = add_put_records_throttled_alarm
        if add_read_provisioned_throughput_exceeded_alarm is not None:
            self._values["add_read_provisioned_throughput_exceeded_alarm"] = add_read_provisioned_throughput_exceeded_alarm
        if add_throttled_records_alarm is not None:
            self._values["add_throttled_records_alarm"] = add_throttled_records_alarm
        if add_write_provisioned_throughput_exceeded_alarm is not None:
            self._values["add_write_provisioned_throughput_exceeded_alarm"] = add_write_provisioned_throughput_exceeded_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def stream_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("stream_name")
        assert result is not None, "Required property 'stream_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_iterator_max_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIteratorAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_iterator_max_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIteratorAgeThreshold]], result)

    @builtins.property
    def add_put_records_failed_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsFailedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_put_records_failed_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsFailedThreshold]], result)

    @builtins.property
    def add_put_records_throttled_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_put_records_throttled_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_read_provisioned_throughput_exceeded_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_read_provisioned_throughput_exceeded_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_throttled_records_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttled_records_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    @builtins.property
    def add_write_provisioned_throughput_exceeded_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_write_provisioned_throughput_exceeded_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisDataStreamMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class KinesisFirehoseMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.KinesisFirehoseMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        delivery_stream_name: builtins.str,
        add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param delivery_stream_name: 
        :param add_incoming_bytes_exceed_threshold_alarm: 
        :param add_incoming_put_requests_exceed_threshold_alarm: 
        :param add_incoming_records_exceed_threshold_alarm: 
        :param add_records_throttled_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__065ad9b14181455cd68f4ec57b6e6fa323b1947106fa92257acbb1364b960bde)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = KinesisFirehoseMonitoringProps(
            delivery_stream_name=delivery_stream_name,
            add_incoming_bytes_exceed_threshold_alarm=add_incoming_bytes_exceed_threshold_alarm,
            add_incoming_put_requests_exceed_threshold_alarm=add_incoming_put_requests_exceed_threshold_alarm,
            add_incoming_records_exceed_threshold_alarm=add_incoming_records_exceed_threshold_alarm,
            add_records_throttled_alarm=add_records_throttled_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createConversionWidget")
    def create_conversion_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca36ae3ee4b6407d048dc54c02d4bca984785c7effbe55c9e456d173a9eeedd5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createConversionWidget", [width, height]))

    @jsii.member(jsii_name="createIncomingRecordWidget")
    def create_incoming_record_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0a47375abd5091071d99d5b9fdc60e88515a5b25a633144c49e003880824844)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createIncomingRecordWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bcb7b25b6ab028683fdec5a181b9de182fb9a8c0330bae810dc0262b1167e78)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createLimitWidget")
    def create_limit_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aeaef5bf14c4986829aefe302a614af8deee99eab851bfa9fc9f467a4dec0cf7)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLimitWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="failedConversionMetric")
    def failed_conversion_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "failedConversionMetric"))

    @builtins.property
    @jsii.member(jsii_name="incomingBytesMetric")
    def incoming_bytes_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingBytesMetric"))

    @builtins.property
    @jsii.member(jsii_name="incomingBytesToLimitRate")
    def incoming_bytes_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingBytesToLimitRate"))

    @builtins.property
    @jsii.member(jsii_name="incomingLimitAnnotations")
    def incoming_limit_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "incomingLimitAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="incomingPutRequestsToLimitRate")
    def incoming_put_requests_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingPutRequestsToLimitRate"))

    @builtins.property
    @jsii.member(jsii_name="incomingRecordsMetric")
    def incoming_records_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingRecordsMetric"))

    @builtins.property
    @jsii.member(jsii_name="incomingRecordsToLimitRate")
    def incoming_records_to_limit_rate(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingRecordsToLimitRate"))

    @builtins.property
    @jsii.member(jsii_name="kinesisAlarmFactory")
    def kinesis_alarm_factory(self) -> KinesisAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(KinesisAlarmFactory, jsii.get(self, "kinesisAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="putRecordBatchLatency")
    def put_record_batch_latency(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordBatchLatency"))

    @builtins.property
    @jsii.member(jsii_name="putRecordLatency")
    def put_record_latency(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "putRecordLatency"))

    @builtins.property
    @jsii.member(jsii_name="recordCountAnnotations")
    def record_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "recordCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="successfulConversionMetric")
    def successful_conversion_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "successfulConversionMetric"))

    @builtins.property
    @jsii.member(jsii_name="throttledRecordsMetric")
    def throttled_records_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "throttledRecordsMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="streamUrl")
    def stream_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "streamUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisFirehoseMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_incoming_bytes_exceed_threshold_alarm": "addIncomingBytesExceedThresholdAlarm",
        "add_incoming_put_requests_exceed_threshold_alarm": "addIncomingPutRequestsExceedThresholdAlarm",
        "add_incoming_records_exceed_threshold_alarm": "addIncomingRecordsExceedThresholdAlarm",
        "add_records_throttled_alarm": "addRecordsThrottledAlarm",
    },
)
class KinesisFirehoseMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_incoming_bytes_exceed_threshold_alarm: 
        :param add_incoming_put_requests_exceed_threshold_alarm: 
        :param add_incoming_records_exceed_threshold_alarm: 
        :param add_records_throttled_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__47ca1db0d356b32d6fb3bf272efed23d37bcc2a0f10a7e7a3891d2801fcbd270)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_incoming_bytes_exceed_threshold_alarm", value=add_incoming_bytes_exceed_threshold_alarm, expected_type=type_hints["add_incoming_bytes_exceed_threshold_alarm"])
            check_type(argname="argument add_incoming_put_requests_exceed_threshold_alarm", value=add_incoming_put_requests_exceed_threshold_alarm, expected_type=type_hints["add_incoming_put_requests_exceed_threshold_alarm"])
            check_type(argname="argument add_incoming_records_exceed_threshold_alarm", value=add_incoming_records_exceed_threshold_alarm, expected_type=type_hints["add_incoming_records_exceed_threshold_alarm"])
            check_type(argname="argument add_records_throttled_alarm", value=add_records_throttled_alarm, expected_type=type_hints["add_records_throttled_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_incoming_bytes_exceed_threshold_alarm is not None:
            self._values["add_incoming_bytes_exceed_threshold_alarm"] = add_incoming_bytes_exceed_threshold_alarm
        if add_incoming_put_requests_exceed_threshold_alarm is not None:
            self._values["add_incoming_put_requests_exceed_threshold_alarm"] = add_incoming_put_requests_exceed_threshold_alarm
        if add_incoming_records_exceed_threshold_alarm is not None:
            self._values["add_incoming_records_exceed_threshold_alarm"] = add_incoming_records_exceed_threshold_alarm
        if add_records_throttled_alarm is not None:
            self._values["add_records_throttled_alarm"] = add_records_throttled_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_incoming_bytes_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_bytes_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_incoming_put_requests_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_put_requests_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_incoming_records_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_records_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_records_throttled_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_records_throttled_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisFirehoseMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.KinesisFirehoseMonitoringProps",
    jsii_struct_bases=[
        KinesisFirehoseMetricFactoryProps, KinesisFirehoseMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "delivery_stream_name": "deliveryStreamName",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_incoming_bytes_exceed_threshold_alarm": "addIncomingBytesExceedThresholdAlarm",
        "add_incoming_put_requests_exceed_threshold_alarm": "addIncomingPutRequestsExceedThresholdAlarm",
        "add_incoming_records_exceed_threshold_alarm": "addIncomingRecordsExceedThresholdAlarm",
        "add_records_throttled_alarm": "addRecordsThrottledAlarm",
    },
)
class KinesisFirehoseMonitoringProps(
    KinesisFirehoseMetricFactoryProps,
    KinesisFirehoseMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        delivery_stream_name: builtins.str,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param delivery_stream_name: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_incoming_bytes_exceed_threshold_alarm: 
        :param add_incoming_put_requests_exceed_threshold_alarm: 
        :param add_incoming_records_exceed_threshold_alarm: 
        :param add_records_throttled_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0fad3079fdd7e7a614d6e6640d09dc2a27dd48aad835bb01d5368ac9d0178c8f)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument delivery_stream_name", value=delivery_stream_name, expected_type=type_hints["delivery_stream_name"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_incoming_bytes_exceed_threshold_alarm", value=add_incoming_bytes_exceed_threshold_alarm, expected_type=type_hints["add_incoming_bytes_exceed_threshold_alarm"])
            check_type(argname="argument add_incoming_put_requests_exceed_threshold_alarm", value=add_incoming_put_requests_exceed_threshold_alarm, expected_type=type_hints["add_incoming_put_requests_exceed_threshold_alarm"])
            check_type(argname="argument add_incoming_records_exceed_threshold_alarm", value=add_incoming_records_exceed_threshold_alarm, expected_type=type_hints["add_incoming_records_exceed_threshold_alarm"])
            check_type(argname="argument add_records_throttled_alarm", value=add_records_throttled_alarm, expected_type=type_hints["add_records_throttled_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "delivery_stream_name": delivery_stream_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_incoming_bytes_exceed_threshold_alarm is not None:
            self._values["add_incoming_bytes_exceed_threshold_alarm"] = add_incoming_bytes_exceed_threshold_alarm
        if add_incoming_put_requests_exceed_threshold_alarm is not None:
            self._values["add_incoming_put_requests_exceed_threshold_alarm"] = add_incoming_put_requests_exceed_threshold_alarm
        if add_incoming_records_exceed_threshold_alarm is not None:
            self._values["add_incoming_records_exceed_threshold_alarm"] = add_incoming_records_exceed_threshold_alarm
        if add_records_throttled_alarm is not None:
            self._values["add_records_throttled_alarm"] = add_records_throttled_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def delivery_stream_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("delivery_stream_name")
        assert result is not None, "Required property 'delivery_stream_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_incoming_bytes_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_bytes_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_incoming_put_requests_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_put_requests_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_incoming_records_exceed_threshold_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_incoming_records_exceed_threshold_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FirehoseStreamLimitThreshold]], result)

    @builtins.property
    def add_records_throttled_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_records_throttled_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RecordsThrottledThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KinesisFirehoseMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LambdaFunctionMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LambdaFunctionMonitoring",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        lambda_insights_enabled: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        is_iterator: typing.Optional[builtins.bool] = None,
        is_offset_lag: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param lambda_function: 
        :param fill_tps_with_zeroes: Default: - true
        :param lambda_insights_enabled: (experimental) Generate dashboard charts for Lambda Insights metrics. To enable Lambda Insights on your Lambda function, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html Default: - false
        :param rate_computation_method: Default: - average
        :param add_concurrent_executions_count_alarm: 
        :param add_enhanced_monitoring_avg_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_avg_memory_utilization_alarm: 
        :param add_enhanced_monitoring_max_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_max_memory_utilization_alarm: 
        :param add_enhanced_monitoring_p90_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_p90_memory_utilization_alarm: 
        :param add_fault_count_alarm: 
        :param add_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param add_max_iterator_age_alarm: 
        :param add_max_latency_alarm: 
        :param add_max_offset_lag_alarm: 
        :param add_min_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_rate_alarm: 
        :param add_throttles_count_alarm: 
        :param add_throttles_rate_alarm: 
        :param is_iterator: (experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm. Default: - true
        :param is_offset_lag: (experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm. Default: - false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12b84d235b139177523803700e7a659a1b35e11854610a7d0fe1cef454da0e64)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = LambdaFunctionMonitoringProps(
            lambda_function=lambda_function,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            lambda_insights_enabled=lambda_insights_enabled,
            rate_computation_method=rate_computation_method,
            add_concurrent_executions_count_alarm=add_concurrent_executions_count_alarm,
            add_enhanced_monitoring_avg_cpu_total_time_alarm=add_enhanced_monitoring_avg_cpu_total_time_alarm,
            add_enhanced_monitoring_avg_memory_utilization_alarm=add_enhanced_monitoring_avg_memory_utilization_alarm,
            add_enhanced_monitoring_max_cpu_total_time_alarm=add_enhanced_monitoring_max_cpu_total_time_alarm,
            add_enhanced_monitoring_max_memory_utilization_alarm=add_enhanced_monitoring_max_memory_utilization_alarm,
            add_enhanced_monitoring_p90_cpu_total_time_alarm=add_enhanced_monitoring_p90_cpu_total_time_alarm,
            add_enhanced_monitoring_p90_memory_utilization_alarm=add_enhanced_monitoring_p90_memory_utilization_alarm,
            add_fault_count_alarm=add_fault_count_alarm,
            add_fault_rate_alarm=add_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            add_max_iterator_age_alarm=add_max_iterator_age_alarm,
            add_max_latency_alarm=add_max_latency_alarm,
            add_max_offset_lag_alarm=add_max_offset_lag_alarm,
            add_min_invocations_count_alarm=add_min_invocations_count_alarm,
            add_provisioned_concurrency_spillover_invocations_count_alarm=add_provisioned_concurrency_spillover_invocations_count_alarm,
            add_provisioned_concurrency_spillover_invocations_rate_alarm=add_provisioned_concurrency_spillover_invocations_rate_alarm,
            add_throttles_count_alarm=add_throttles_count_alarm,
            add_throttles_rate_alarm=add_throttles_rate_alarm,
            is_iterator=is_iterator,
            is_offset_lag=is_offset_lag,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createErrorCountWidget")
    def create_error_count_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__66bdff6e38dc362f7604424cf0f646e7e95aef1962ad2696ef69715c9f208718)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorCountWidget", [width, height]))

    @jsii.member(jsii_name="createErrorRateWidget")
    def create_error_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__91fa11c48155999cf862cdc68ea2a9ab029bd489c80bbcb8aa10bb7438d16a2b)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createErrorRateWidget", [width, height]))

    @jsii.member(jsii_name="createInvocationWidget")
    def create_invocation_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b0cd40e878a439afe6ec9b5402342bfc4f03dcf2ce9d9a5811f330bfcbf062a1)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createInvocationWidget", [width, height]))

    @jsii.member(jsii_name="createIteratorAgeWidget")
    def create_iterator_age_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29d896254371de4780c8bef41eeab95f954ce07af3d151e947ed2b22607e6fb3)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createIteratorAgeWidget", [width, height]))

    @jsii.member(jsii_name="createLambdaInsightsCpuWidget")
    def create_lambda_insights_cpu_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__268ade446bcf584fd293487eb0ce7c3f437fcf2cc3350ad06207d3a6949dd7c9)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLambdaInsightsCpuWidget", [width, height]))

    @jsii.member(jsii_name="createLambdaInsightsFunctionCostWidget")
    def create_lambda_insights_function_cost_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82141ab86ab8856b3bbdb39e68abfcfaca2e3f807ac39a994dc67c715f137332)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLambdaInsightsFunctionCostWidget", [width, height]))

    @jsii.member(jsii_name="createLambdaInsightsMemoryWidget")
    def create_lambda_insights_memory_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__707cce4c1a38dc181ab4f192e5e343ba8369a3d8bf198febafa5418c27c85ae5)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLambdaInsightsMemoryWidget", [width, height]))

    @jsii.member(jsii_name="createLatencyWidget")
    def create_latency_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cc84570eb583f94f0f00be915b90472b4e3d6b003587020520e8d4d70c448f37)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createLatencyWidget", [width, height]))

    @jsii.member(jsii_name="createOffsetLagWidget")
    def create_offset_lag_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1ceeab89d65ac18063152248973d859e7bc057b2386cd05b4b6d2f87847a216)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createOffsetLagWidget", [width, height]))

    @jsii.member(jsii_name="createRateWidget")
    def create_rate_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a663670c545c7321f11d8f943a6ad49377643e0ac8540b8e5014ba52a6327d3)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createRateWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="createTpsWidget")
    def create_tps_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__209e79a88961e04f21d8d8eb144c49a1ce8879a0b18068df9a04ec2ec7740680)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createTpsWidget", [width, height]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="ageAlarmFactory")
    def age_alarm_factory(self) -> AgeAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AgeAlarmFactory, jsii.get(self, "ageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="concurrentExecutionsCountMetric")
    def concurrent_executions_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "concurrentExecutionsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="cpuTotalTimeAnnotations")
    def cpu_total_time_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "cpuTotalTimeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorAlarmFactory")
    def error_alarm_factory(self) -> ErrorAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(ErrorAlarmFactory, jsii.get(self, "errorAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="errorCountAnnotations")
    def error_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="errorRateAnnotations")
    def error_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "errorRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="faultCountMetric")
    def fault_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "faultCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="faultRateMetric")
    def fault_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "faultRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="invocationCountAnnotations")
    def invocation_count_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "invocationCountAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="invocationCountMetric")
    def invocation_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "invocationCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="invocationRateAnnotations")
    def invocation_rate_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "invocationRateAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="isIterator")
    def is_iterator(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "isIterator"))

    @builtins.property
    @jsii.member(jsii_name="isOffsetLag")
    def is_offset_lag(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "isOffsetLag"))

    @builtins.property
    @jsii.member(jsii_name="lambdaInsightsEnabled")
    def lambda_insights_enabled(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "lambdaInsightsEnabled"))

    @builtins.property
    @jsii.member(jsii_name="latencyAlarmFactory")
    def latency_alarm_factory(self) -> LatencyAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LatencyAlarmFactory, jsii.get(self, "latencyAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="latencyAnnotations")
    def latency_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "latencyAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="maxIteratorAgeAnnotations")
    def max_iterator_age_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "maxIteratorAgeAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="maxIteratorAgeMetric")
    def max_iterator_age_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "maxIteratorAgeMetric"))

    @builtins.property
    @jsii.member(jsii_name="maxLatencyMetric")
    def max_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "maxLatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="maxOffsetLagAnnotations")
    def max_offset_lag_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "maxOffsetLagAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="maxOffsetLagMetric")
    def max_offset_lag_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "maxOffsetLagMetric"))

    @builtins.property
    @jsii.member(jsii_name="memoryUsageAnnotations")
    def memory_usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "memoryUsageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="metricFactory")
    def metric_factory(self) -> LambdaFunctionMetricFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(LambdaFunctionMetricFactory, jsii.get(self, "metricFactory"))

    @builtins.property
    @jsii.member(jsii_name="namingStrategy")
    def naming_strategy(self) -> MonitoringNamingStrategy:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringNamingStrategy, jsii.get(self, "namingStrategy"))

    @builtins.property
    @jsii.member(jsii_name="p50LatencyMetric")
    def p50_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p50LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p90LatencyMetric")
    def p90_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p90LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="p99LatencyMetric")
    def p99_latency_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "p99LatencyMetric"))

    @builtins.property
    @jsii.member(jsii_name="provisionedConcurrencySpilloverInvocationsCountMetric")
    def provisioned_concurrency_spillover_invocations_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedConcurrencySpilloverInvocationsCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="provisionedConcurrencySpilloverInvocationsRateMetric")
    def provisioned_concurrency_spillover_invocations_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "provisionedConcurrencySpilloverInvocationsRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="taskHealthAlarmFactory")
    def task_health_alarm_factory(self) -> TaskHealthAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TaskHealthAlarmFactory, jsii.get(self, "taskHealthAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="throttlesCountMetric")
    def throttles_count_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "throttlesCountMetric"))

    @builtins.property
    @jsii.member(jsii_name="throttlesRateMetric")
    def throttles_rate_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "throttlesRateMetric"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "title"))

    @builtins.property
    @jsii.member(jsii_name="tpsAlarmFactory")
    def tps_alarm_factory(self) -> TpsAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(TpsAlarmFactory, jsii.get(self, "tpsAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="tpsAnnotations")
    def tps_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "tpsAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="tpsMetric")
    def tps_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "tpsMetric"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMetricFactory")
    def enhanced_metric_factory(
        self,
    ) -> typing.Optional[LambdaFunctionEnhancedMetricFactory]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[LambdaFunctionEnhancedMetricFactory], jsii.get(self, "enhancedMetricFactory"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMetricFunctionCostMetric")
    def enhanced_metric_function_cost_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMetricFunctionCostMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringAvgCpuTotalTimeMetric")
    def enhanced_monitoring_avg_cpu_total_time_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringAvgCpuTotalTimeMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringAvgMemoryUtilizationMetric")
    def enhanced_monitoring_avg_memory_utilization_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringAvgMemoryUtilizationMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringMaxCpuTotalTimeMetric")
    def enhanced_monitoring_max_cpu_total_time_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringMaxCpuTotalTimeMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringMaxMemoryUtilizationMetric")
    def enhanced_monitoring_max_memory_utilization_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringMaxMemoryUtilizationMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringP90CpuTotalTimeMetric")
    def enhanced_monitoring_p90_cpu_total_time_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringP90CpuTotalTimeMetric"))

    @builtins.property
    @jsii.member(jsii_name="enhancedMonitoringP90MemoryUtilizationMetric")
    def enhanced_monitoring_p90_memory_utilization_metric(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]], jsii.get(self, "enhancedMonitoringP90MemoryUtilizationMetric"))

    @builtins.property
    @jsii.member(jsii_name="functionUrl")
    def function_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "functionUrl"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LambdaFunctionMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_concurrent_executions_count_alarm": "addConcurrentExecutionsCountAlarm",
        "add_enhanced_monitoring_avg_cpu_total_time_alarm": "addEnhancedMonitoringAvgCpuTotalTimeAlarm",
        "add_enhanced_monitoring_avg_memory_utilization_alarm": "addEnhancedMonitoringAvgMemoryUtilizationAlarm",
        "add_enhanced_monitoring_max_cpu_total_time_alarm": "addEnhancedMonitoringMaxCpuTotalTimeAlarm",
        "add_enhanced_monitoring_max_memory_utilization_alarm": "addEnhancedMonitoringMaxMemoryUtilizationAlarm",
        "add_enhanced_monitoring_p90_cpu_total_time_alarm": "addEnhancedMonitoringP90CpuTotalTimeAlarm",
        "add_enhanced_monitoring_p90_memory_utilization_alarm": "addEnhancedMonitoringP90MemoryUtilizationAlarm",
        "add_fault_count_alarm": "addFaultCountAlarm",
        "add_fault_rate_alarm": "addFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "add_max_iterator_age_alarm": "addMaxIteratorAgeAlarm",
        "add_max_latency_alarm": "addMaxLatencyAlarm",
        "add_max_offset_lag_alarm": "addMaxOffsetLagAlarm",
        "add_min_invocations_count_alarm": "addMinInvocationsCountAlarm",
        "add_provisioned_concurrency_spillover_invocations_count_alarm": "addProvisionedConcurrencySpilloverInvocationsCountAlarm",
        "add_provisioned_concurrency_spillover_invocations_rate_alarm": "addProvisionedConcurrencySpilloverInvocationsRateAlarm",
        "add_throttles_count_alarm": "addThrottlesCountAlarm",
        "add_throttles_rate_alarm": "addThrottlesRateAlarm",
        "is_iterator": "isIterator",
        "is_offset_lag": "isOffsetLag",
    },
)
class LambdaFunctionMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        is_iterator: typing.Optional[builtins.bool] = None,
        is_offset_lag: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_concurrent_executions_count_alarm: 
        :param add_enhanced_monitoring_avg_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_avg_memory_utilization_alarm: 
        :param add_enhanced_monitoring_max_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_max_memory_utilization_alarm: 
        :param add_enhanced_monitoring_p90_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_p90_memory_utilization_alarm: 
        :param add_fault_count_alarm: 
        :param add_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param add_max_iterator_age_alarm: 
        :param add_max_latency_alarm: 
        :param add_max_offset_lag_alarm: 
        :param add_min_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_rate_alarm: 
        :param add_throttles_count_alarm: 
        :param add_throttles_rate_alarm: 
        :param is_iterator: (experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm. Default: - true
        :param is_offset_lag: (experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm. Default: - false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d18010941a2fe9b0b270b6130d7129562e7b9987185867d493ca3d179cffe35c)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_concurrent_executions_count_alarm", value=add_concurrent_executions_count_alarm, expected_type=type_hints["add_concurrent_executions_count_alarm"])
            check_type(argname="argument add_enhanced_monitoring_avg_cpu_total_time_alarm", value=add_enhanced_monitoring_avg_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_avg_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_avg_memory_utilization_alarm", value=add_enhanced_monitoring_avg_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_avg_memory_utilization_alarm"])
            check_type(argname="argument add_enhanced_monitoring_max_cpu_total_time_alarm", value=add_enhanced_monitoring_max_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_max_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_max_memory_utilization_alarm", value=add_enhanced_monitoring_max_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_max_memory_utilization_alarm"])
            check_type(argname="argument add_enhanced_monitoring_p90_cpu_total_time_alarm", value=add_enhanced_monitoring_p90_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_p90_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_p90_memory_utilization_alarm", value=add_enhanced_monitoring_p90_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_p90_memory_utilization_alarm"])
            check_type(argname="argument add_fault_count_alarm", value=add_fault_count_alarm, expected_type=type_hints["add_fault_count_alarm"])
            check_type(argname="argument add_fault_rate_alarm", value=add_fault_rate_alarm, expected_type=type_hints["add_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument add_max_iterator_age_alarm", value=add_max_iterator_age_alarm, expected_type=type_hints["add_max_iterator_age_alarm"])
            check_type(argname="argument add_max_latency_alarm", value=add_max_latency_alarm, expected_type=type_hints["add_max_latency_alarm"])
            check_type(argname="argument add_max_offset_lag_alarm", value=add_max_offset_lag_alarm, expected_type=type_hints["add_max_offset_lag_alarm"])
            check_type(argname="argument add_min_invocations_count_alarm", value=add_min_invocations_count_alarm, expected_type=type_hints["add_min_invocations_count_alarm"])
            check_type(argname="argument add_provisioned_concurrency_spillover_invocations_count_alarm", value=add_provisioned_concurrency_spillover_invocations_count_alarm, expected_type=type_hints["add_provisioned_concurrency_spillover_invocations_count_alarm"])
            check_type(argname="argument add_provisioned_concurrency_spillover_invocations_rate_alarm", value=add_provisioned_concurrency_spillover_invocations_rate_alarm, expected_type=type_hints["add_provisioned_concurrency_spillover_invocations_rate_alarm"])
            check_type(argname="argument add_throttles_count_alarm", value=add_throttles_count_alarm, expected_type=type_hints["add_throttles_count_alarm"])
            check_type(argname="argument add_throttles_rate_alarm", value=add_throttles_rate_alarm, expected_type=type_hints["add_throttles_rate_alarm"])
            check_type(argname="argument is_iterator", value=is_iterator, expected_type=type_hints["is_iterator"])
            check_type(argname="argument is_offset_lag", value=is_offset_lag, expected_type=type_hints["is_offset_lag"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_concurrent_executions_count_alarm is not None:
            self._values["add_concurrent_executions_count_alarm"] = add_concurrent_executions_count_alarm
        if add_enhanced_monitoring_avg_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_avg_cpu_total_time_alarm"] = add_enhanced_monitoring_avg_cpu_total_time_alarm
        if add_enhanced_monitoring_avg_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_avg_memory_utilization_alarm"] = add_enhanced_monitoring_avg_memory_utilization_alarm
        if add_enhanced_monitoring_max_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_max_cpu_total_time_alarm"] = add_enhanced_monitoring_max_cpu_total_time_alarm
        if add_enhanced_monitoring_max_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_max_memory_utilization_alarm"] = add_enhanced_monitoring_max_memory_utilization_alarm
        if add_enhanced_monitoring_p90_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_p90_cpu_total_time_alarm"] = add_enhanced_monitoring_p90_cpu_total_time_alarm
        if add_enhanced_monitoring_p90_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_p90_memory_utilization_alarm"] = add_enhanced_monitoring_p90_memory_utilization_alarm
        if add_fault_count_alarm is not None:
            self._values["add_fault_count_alarm"] = add_fault_count_alarm
        if add_fault_rate_alarm is not None:
            self._values["add_fault_rate_alarm"] = add_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if add_max_iterator_age_alarm is not None:
            self._values["add_max_iterator_age_alarm"] = add_max_iterator_age_alarm
        if add_max_latency_alarm is not None:
            self._values["add_max_latency_alarm"] = add_max_latency_alarm
        if add_max_offset_lag_alarm is not None:
            self._values["add_max_offset_lag_alarm"] = add_max_offset_lag_alarm
        if add_min_invocations_count_alarm is not None:
            self._values["add_min_invocations_count_alarm"] = add_min_invocations_count_alarm
        if add_provisioned_concurrency_spillover_invocations_count_alarm is not None:
            self._values["add_provisioned_concurrency_spillover_invocations_count_alarm"] = add_provisioned_concurrency_spillover_invocations_count_alarm
        if add_provisioned_concurrency_spillover_invocations_rate_alarm is not None:
            self._values["add_provisioned_concurrency_spillover_invocations_rate_alarm"] = add_provisioned_concurrency_spillover_invocations_rate_alarm
        if add_throttles_count_alarm is not None:
            self._values["add_throttles_count_alarm"] = add_throttles_count_alarm
        if add_throttles_rate_alarm is not None:
            self._values["add_throttles_rate_alarm"] = add_throttles_rate_alarm
        if is_iterator is not None:
            self._values["is_iterator"] = is_iterator
        if is_offset_lag is not None:
            self._values["is_offset_lag"] = is_offset_lag

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_concurrent_executions_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_concurrent_executions_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_avg_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_avg_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_avg_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_avg_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_max_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_max_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_max_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_max_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_p90_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_p90_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_p90_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_p90_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def add_max_iterator_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_iterator_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxAgeThreshold]], result)

    @builtins.property
    def add_max_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_max_offset_lag_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxOffsetLagThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_offset_lag_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxOffsetLagThreshold]], result)

    @builtins.property
    def add_min_invocations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_invocations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_provisioned_concurrency_spillover_invocations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_provisioned_concurrency_spillover_invocations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def add_provisioned_concurrency_spillover_invocations_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_provisioned_concurrency_spillover_invocations_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskRateThreshold]], result)

    @builtins.property
    def add_throttles_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttles_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_throttles_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttles_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def is_iterator(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("is_iterator")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def is_offset_lag(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("is_offset_lag")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaFunctionMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LambdaFunctionMonitoringProps",
    jsii_struct_bases=[
        LambdaFunctionMetricFactoryProps, LambdaFunctionMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "lambda_function": "lambdaFunction",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "lambda_insights_enabled": "lambdaInsightsEnabled",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_concurrent_executions_count_alarm": "addConcurrentExecutionsCountAlarm",
        "add_enhanced_monitoring_avg_cpu_total_time_alarm": "addEnhancedMonitoringAvgCpuTotalTimeAlarm",
        "add_enhanced_monitoring_avg_memory_utilization_alarm": "addEnhancedMonitoringAvgMemoryUtilizationAlarm",
        "add_enhanced_monitoring_max_cpu_total_time_alarm": "addEnhancedMonitoringMaxCpuTotalTimeAlarm",
        "add_enhanced_monitoring_max_memory_utilization_alarm": "addEnhancedMonitoringMaxMemoryUtilizationAlarm",
        "add_enhanced_monitoring_p90_cpu_total_time_alarm": "addEnhancedMonitoringP90CpuTotalTimeAlarm",
        "add_enhanced_monitoring_p90_memory_utilization_alarm": "addEnhancedMonitoringP90MemoryUtilizationAlarm",
        "add_fault_count_alarm": "addFaultCountAlarm",
        "add_fault_rate_alarm": "addFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "add_max_iterator_age_alarm": "addMaxIteratorAgeAlarm",
        "add_max_latency_alarm": "addMaxLatencyAlarm",
        "add_max_offset_lag_alarm": "addMaxOffsetLagAlarm",
        "add_min_invocations_count_alarm": "addMinInvocationsCountAlarm",
        "add_provisioned_concurrency_spillover_invocations_count_alarm": "addProvisionedConcurrencySpilloverInvocationsCountAlarm",
        "add_provisioned_concurrency_spillover_invocations_rate_alarm": "addProvisionedConcurrencySpilloverInvocationsRateAlarm",
        "add_throttles_count_alarm": "addThrottlesCountAlarm",
        "add_throttles_rate_alarm": "addThrottlesRateAlarm",
        "is_iterator": "isIterator",
        "is_offset_lag": "isOffsetLag",
    },
)
class LambdaFunctionMonitoringProps(
    LambdaFunctionMetricFactoryProps,
    LambdaFunctionMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        lambda_insights_enabled: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        is_iterator: typing.Optional[builtins.bool] = None,
        is_offset_lag: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param lambda_function: 
        :param fill_tps_with_zeroes: Default: - true
        :param lambda_insights_enabled: (experimental) Generate dashboard charts for Lambda Insights metrics. To enable Lambda Insights on your Lambda function, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html Default: - false
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_concurrent_executions_count_alarm: 
        :param add_enhanced_monitoring_avg_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_avg_memory_utilization_alarm: 
        :param add_enhanced_monitoring_max_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_max_memory_utilization_alarm: 
        :param add_enhanced_monitoring_p90_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_p90_memory_utilization_alarm: 
        :param add_fault_count_alarm: 
        :param add_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param add_max_iterator_age_alarm: 
        :param add_max_latency_alarm: 
        :param add_max_offset_lag_alarm: 
        :param add_min_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_rate_alarm: 
        :param add_throttles_count_alarm: 
        :param add_throttles_rate_alarm: 
        :param is_iterator: (experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm. Default: - true
        :param is_offset_lag: (experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm. Default: - false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8e65969145bc6a53291f4fa8a76f0fc046e32d4e8056c2f0869c3a84e28b7ee1)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument lambda_insights_enabled", value=lambda_insights_enabled, expected_type=type_hints["lambda_insights_enabled"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_concurrent_executions_count_alarm", value=add_concurrent_executions_count_alarm, expected_type=type_hints["add_concurrent_executions_count_alarm"])
            check_type(argname="argument add_enhanced_monitoring_avg_cpu_total_time_alarm", value=add_enhanced_monitoring_avg_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_avg_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_avg_memory_utilization_alarm", value=add_enhanced_monitoring_avg_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_avg_memory_utilization_alarm"])
            check_type(argname="argument add_enhanced_monitoring_max_cpu_total_time_alarm", value=add_enhanced_monitoring_max_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_max_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_max_memory_utilization_alarm", value=add_enhanced_monitoring_max_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_max_memory_utilization_alarm"])
            check_type(argname="argument add_enhanced_monitoring_p90_cpu_total_time_alarm", value=add_enhanced_monitoring_p90_cpu_total_time_alarm, expected_type=type_hints["add_enhanced_monitoring_p90_cpu_total_time_alarm"])
            check_type(argname="argument add_enhanced_monitoring_p90_memory_utilization_alarm", value=add_enhanced_monitoring_p90_memory_utilization_alarm, expected_type=type_hints["add_enhanced_monitoring_p90_memory_utilization_alarm"])
            check_type(argname="argument add_fault_count_alarm", value=add_fault_count_alarm, expected_type=type_hints["add_fault_count_alarm"])
            check_type(argname="argument add_fault_rate_alarm", value=add_fault_rate_alarm, expected_type=type_hints["add_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument add_max_iterator_age_alarm", value=add_max_iterator_age_alarm, expected_type=type_hints["add_max_iterator_age_alarm"])
            check_type(argname="argument add_max_latency_alarm", value=add_max_latency_alarm, expected_type=type_hints["add_max_latency_alarm"])
            check_type(argname="argument add_max_offset_lag_alarm", value=add_max_offset_lag_alarm, expected_type=type_hints["add_max_offset_lag_alarm"])
            check_type(argname="argument add_min_invocations_count_alarm", value=add_min_invocations_count_alarm, expected_type=type_hints["add_min_invocations_count_alarm"])
            check_type(argname="argument add_provisioned_concurrency_spillover_invocations_count_alarm", value=add_provisioned_concurrency_spillover_invocations_count_alarm, expected_type=type_hints["add_provisioned_concurrency_spillover_invocations_count_alarm"])
            check_type(argname="argument add_provisioned_concurrency_spillover_invocations_rate_alarm", value=add_provisioned_concurrency_spillover_invocations_rate_alarm, expected_type=type_hints["add_provisioned_concurrency_spillover_invocations_rate_alarm"])
            check_type(argname="argument add_throttles_count_alarm", value=add_throttles_count_alarm, expected_type=type_hints["add_throttles_count_alarm"])
            check_type(argname="argument add_throttles_rate_alarm", value=add_throttles_rate_alarm, expected_type=type_hints["add_throttles_rate_alarm"])
            check_type(argname="argument is_iterator", value=is_iterator, expected_type=type_hints["is_iterator"])
            check_type(argname="argument is_offset_lag", value=is_offset_lag, expected_type=type_hints["is_offset_lag"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "lambda_function": lambda_function,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if lambda_insights_enabled is not None:
            self._values["lambda_insights_enabled"] = lambda_insights_enabled
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_concurrent_executions_count_alarm is not None:
            self._values["add_concurrent_executions_count_alarm"] = add_concurrent_executions_count_alarm
        if add_enhanced_monitoring_avg_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_avg_cpu_total_time_alarm"] = add_enhanced_monitoring_avg_cpu_total_time_alarm
        if add_enhanced_monitoring_avg_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_avg_memory_utilization_alarm"] = add_enhanced_monitoring_avg_memory_utilization_alarm
        if add_enhanced_monitoring_max_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_max_cpu_total_time_alarm"] = add_enhanced_monitoring_max_cpu_total_time_alarm
        if add_enhanced_monitoring_max_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_max_memory_utilization_alarm"] = add_enhanced_monitoring_max_memory_utilization_alarm
        if add_enhanced_monitoring_p90_cpu_total_time_alarm is not None:
            self._values["add_enhanced_monitoring_p90_cpu_total_time_alarm"] = add_enhanced_monitoring_p90_cpu_total_time_alarm
        if add_enhanced_monitoring_p90_memory_utilization_alarm is not None:
            self._values["add_enhanced_monitoring_p90_memory_utilization_alarm"] = add_enhanced_monitoring_p90_memory_utilization_alarm
        if add_fault_count_alarm is not None:
            self._values["add_fault_count_alarm"] = add_fault_count_alarm
        if add_fault_rate_alarm is not None:
            self._values["add_fault_rate_alarm"] = add_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if add_max_iterator_age_alarm is not None:
            self._values["add_max_iterator_age_alarm"] = add_max_iterator_age_alarm
        if add_max_latency_alarm is not None:
            self._values["add_max_latency_alarm"] = add_max_latency_alarm
        if add_max_offset_lag_alarm is not None:
            self._values["add_max_offset_lag_alarm"] = add_max_offset_lag_alarm
        if add_min_invocations_count_alarm is not None:
            self._values["add_min_invocations_count_alarm"] = add_min_invocations_count_alarm
        if add_provisioned_concurrency_spillover_invocations_count_alarm is not None:
            self._values["add_provisioned_concurrency_spillover_invocations_count_alarm"] = add_provisioned_concurrency_spillover_invocations_count_alarm
        if add_provisioned_concurrency_spillover_invocations_rate_alarm is not None:
            self._values["add_provisioned_concurrency_spillover_invocations_rate_alarm"] = add_provisioned_concurrency_spillover_invocations_rate_alarm
        if add_throttles_count_alarm is not None:
            self._values["add_throttles_count_alarm"] = add_throttles_count_alarm
        if add_throttles_rate_alarm is not None:
            self._values["add_throttles_rate_alarm"] = add_throttles_rate_alarm
        if is_iterator is not None:
            self._values["is_iterator"] = is_iterator
        if is_offset_lag is not None:
            self._values["is_offset_lag"] = is_offset_lag

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_function")
        assert result is not None, "Required property 'lambda_function' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def lambda_insights_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Generate dashboard charts for Lambda Insights metrics.

        To enable Lambda Insights on your Lambda function, see
        https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("lambda_insights_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_concurrent_executions_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_concurrent_executions_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_avg_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_avg_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_avg_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_avg_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_max_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_max_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_max_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_max_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_p90_cpu_total_time_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_p90_cpu_total_time_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_enhanced_monitoring_p90_memory_utilization_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_enhanced_monitoring_p90_memory_utilization_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def add_max_iterator_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_iterator_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxAgeThreshold]], result)

    @builtins.property
    def add_max_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_max_offset_lag_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxOffsetLagThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_offset_lag_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxOffsetLagThreshold]], result)

    @builtins.property
    def add_min_invocations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_invocations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_provisioned_concurrency_spillover_invocations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_provisioned_concurrency_spillover_invocations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def add_provisioned_concurrency_spillover_invocations_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_provisioned_concurrency_spillover_invocations_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskRateThreshold]], result)

    @builtins.property
    def add_throttles_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttles_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_throttles_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttles_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def is_iterator(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("is_iterator")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def is_offset_lag(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm.

        :default: - false

        :stability: experimental
        '''
        result = self._values.get("is_offset_lag")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaFunctionMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LogMonitoring(
    Monitoring,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.LogMonitoring",
):
    '''(experimental) Monitors a CloudWatch log group for various patterns.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: MonitoringScope,
        *,
        add_max_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        limit: typing.Optional[jsii.Number] = None,
        pattern: typing.Optional[builtins.str] = None,
        title: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        log_group_name: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param add_max_incoming_logs_alarm: 
        :param add_min_incoming_logs_alarm: 
        :param limit: (experimental) Maximum number of log messages to search for. Default: - 10
        :param pattern: (experimental) Pattern to search for, e.g. "ERROR".
        :param title: (experimental) Widget title. Default: - auto-generated title based on the pattern and limit
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param log_group_name: (experimental) Name of the log group to monitor.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ace7b560e5ce6dc00a079bd030c152359fd0385c6eb9fe63936f6b83d3a0c10e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = LogMonitoringProps(
            add_max_incoming_logs_alarm=add_max_incoming_logs_alarm,
            add_min_incoming_logs_alarm=add_min_incoming_logs_alarm,
            limit=limit,
            pattern=pattern,
            title=title,
            use_created_alarms=use_created_alarms,
            log_group_name=log_group_name,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        jsii.create(self.__class__, self, [scope, props])

    @jsii.member(jsii_name="createIncomingLogsWidget")
    def create_incoming_logs_widget(
        self,
        width: jsii.Number,
        height: jsii.Number,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget:
        '''
        :param width: -
        :param height: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f05326f15012ef001ce1de9cfd486faad1f75d8618226196b191bf79fe4d1fdc)
            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.GraphWidget, jsii.invoke(self, "createIncomingLogsWidget", [width, height]))

    @jsii.member(jsii_name="createTitleWidget")
    def create_title_widget(self) -> MonitoringHeaderWidget:
        '''
        :stability: experimental
        '''
        return typing.cast(MonitoringHeaderWidget, jsii.invoke(self, "createTitleWidget", []))

    @jsii.member(jsii_name="resolveRecommendedHeight")
    def _resolve_recommended_height(self, num_rows: jsii.Number) -> jsii.Number:
        '''
        :param num_rows: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca59d462b6bd07f0e0c737d1a0148125d48b3e52841215381f91f463b7697616)
            check_type(argname="argument num_rows", value=num_rows, expected_type=type_hints["num_rows"])
        return typing.cast(jsii.Number, jsii.invoke(self, "resolveRecommendedHeight", [num_rows]))

    @jsii.member(jsii_name="summaryWidgets")
    def summary_widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the summary dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "summaryWidgets", []))

    @jsii.member(jsii_name="widgets")
    def widgets(self) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]:
        '''(experimental) Returns widgets to be placed on the main dashboard.

        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget], jsii.invoke(self, "widgets", []))

    @builtins.property
    @jsii.member(jsii_name="alarmFactory")
    def alarm_factory(self) -> AlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactory, jsii.get(self, "alarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="incomingLogEventsMetric")
    def incoming_log_events_metric(
        self,
    ) -> typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression], jsii.get(self, "incomingLogEventsMetric"))

    @builtins.property
    @jsii.member(jsii_name="limit")
    def limit(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        return typing.cast(jsii.Number, jsii.get(self, "limit"))

    @builtins.property
    @jsii.member(jsii_name="logGroupName")
    def log_group_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "logGroupName"))

    @builtins.property
    @jsii.member(jsii_name="usageAlarmFactory")
    def usage_alarm_factory(self) -> UsageAlarmFactory:
        '''
        :stability: experimental
        '''
        return typing.cast(UsageAlarmFactory, jsii.get(self, "usageAlarmFactory"))

    @builtins.property
    @jsii.member(jsii_name="usageAnnotations")
    def usage_annotations(
        self,
    ) -> typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation], jsii.get(self, "usageAnnotations"))

    @builtins.property
    @jsii.member(jsii_name="logGroupUrl")
    def log_group_url(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "logGroupUrl"))

    @builtins.property
    @jsii.member(jsii_name="pattern")
    def pattern(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "pattern"))

    @builtins.property
    @jsii.member(jsii_name="title")
    def title(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "title"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.LogMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, CloudWatchLogsMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "log_group_name": "logGroupName",
        "add_max_incoming_logs_alarm": "addMaxIncomingLogsAlarm",
        "add_min_incoming_logs_alarm": "addMinIncomingLogsAlarm",
        "limit": "limit",
        "pattern": "pattern",
        "title": "title",
    },
)
class LogMonitoringProps(BaseMonitoringProps, CloudWatchLogsMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        log_group_name: builtins.str,
        add_max_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        limit: typing.Optional[jsii.Number] = None,
        pattern: typing.Optional[builtins.str] = None,
        title: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param log_group_name: (experimental) Name of the log group to monitor.
        :param add_max_incoming_logs_alarm: 
        :param add_min_incoming_logs_alarm: 
        :param limit: (experimental) Maximum number of log messages to search for. Default: - 10
        :param pattern: (experimental) Pattern to search for, e.g. "ERROR".
        :param title: (experimental) Widget title. Default: - auto-generated title based on the pattern and limit

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff0b48c1359f7ca202031bf8bf34ec397a1faaf3f7a823bfd31d9c984af66346)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument log_group_name", value=log_group_name, expected_type=type_hints["log_group_name"])
            check_type(argname="argument add_max_incoming_logs_alarm", value=add_max_incoming_logs_alarm, expected_type=type_hints["add_max_incoming_logs_alarm"])
            check_type(argname="argument add_min_incoming_logs_alarm", value=add_min_incoming_logs_alarm, expected_type=type_hints["add_min_incoming_logs_alarm"])
            check_type(argname="argument limit", value=limit, expected_type=type_hints["limit"])
            check_type(argname="argument pattern", value=pattern, expected_type=type_hints["pattern"])
            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "log_group_name": log_group_name,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_max_incoming_logs_alarm is not None:
            self._values["add_max_incoming_logs_alarm"] = add_max_incoming_logs_alarm
        if add_min_incoming_logs_alarm is not None:
            self._values["add_min_incoming_logs_alarm"] = add_min_incoming_logs_alarm
        if limit is not None:
            self._values["limit"] = limit
        if pattern is not None:
            self._values["pattern"] = pattern
        if title is not None:
            self._values["title"] = title

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def log_group_name(self) -> builtins.str:
        '''(experimental) Name of the log group to monitor.

        :stability: experimental
        '''
        result = self._values.get("log_group_name")
        assert result is not None, "Required property 'log_group_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def add_max_incoming_logs_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_incoming_logs_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxUsageCountThreshold]], result)

    @builtins.property
    def add_min_incoming_logs_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_incoming_logs_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def limit(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of log messages to search for.

        :default: - 10

        :stability: experimental
        '''
        result = self._values.get("limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def pattern(self) -> typing.Optional[builtins.str]:
        '''(experimental) Pattern to search for, e.g. "ERROR".

        :stability: experimental
        '''
        result = self._values.get("pattern")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def title(self) -> typing.Optional[builtins.str]:
        '''(experimental) Widget title.

        :default: - auto-generated title based on the pattern and limit

        :stability: experimental
        '''
        result = self._values.get("title")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LogMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MonitoringFacade(
    MonitoringScope,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.MonitoringFacade",
):
    '''(experimental) An implementation of a {@link MonitoringScope}.

    This is a convenient main entrypoint to monitor resources.

    Provides methods for retrieving and creating alarms based on added segments that are subclasses of
    {@link Monitoring}.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        alarm_factory_defaults: typing.Optional[typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
        dashboard_factory: typing.Optional[IDynamicDashboardFactory] = None,
        metric_factory_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param alarm_factory_defaults: (experimental) Defaults for alarm factory. Default: - actions enabled, facade logical ID used as default alarm name prefix
        :param dashboard_factory: (experimental) Defaults for dashboard factory. Default: - An instance of {@link DynamicDashboardFactory}; facade logical ID used as default name
        :param metric_factory_defaults: (experimental) Defaults for metric factory. Default: - empty (no preferences)

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60d1916429139435d7fa7a12c2a911f24fc1e8211f5a6f85c97b4a2d0712d588)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = MonitoringFacadeProps(
            alarm_factory_defaults=alarm_factory_defaults,
            dashboard_factory=dashboard_factory,
            metric_factory_defaults=metric_factory_defaults,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addDynamicSegment")
    def add_dynamic_segment(
        self,
        segment: IDynamicDashboardSegment,
    ) -> "MonitoringFacade":
        '''(experimental) Adds a dashboard segment which returns dynamic content depending on dashboard type.

        :param segment: dynamic segment to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d211cb96de28b1c67037c9d133a69565bcd21c189f605b301825b2735e67cc26)
            check_type(argname="argument segment", value=segment, expected_type=type_hints["segment"])
        return typing.cast("MonitoringFacade", jsii.invoke(self, "addDynamicSegment", [segment]))

    @jsii.member(jsii_name="addLargeHeader")
    def add_large_header(
        self,
        text: builtins.str,
        add_to_summary: typing.Optional[builtins.bool] = None,
        add_to_alarm: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param text: -
        :param add_to_summary: -
        :param add_to_alarm: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9d99dfe696828a7f703f8b8b477e2167b83ccb8497245764d3f0e1d77abf6f4)
            check_type(argname="argument text", value=text, expected_type=type_hints["text"])
            check_type(argname="argument add_to_summary", value=add_to_summary, expected_type=type_hints["add_to_summary"])
            check_type(argname="argument add_to_alarm", value=add_to_alarm, expected_type=type_hints["add_to_alarm"])
        return typing.cast("MonitoringFacade", jsii.invoke(self, "addLargeHeader", [text, add_to_summary, add_to_alarm]))

    @jsii.member(jsii_name="addMediumHeader")
    def add_medium_header(
        self,
        text: builtins.str,
        add_to_summary: typing.Optional[builtins.bool] = None,
        add_to_alarm: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param text: -
        :param add_to_summary: -
        :param add_to_alarm: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__abf1f7e12ba4c11b5d140f2552de589dc30c79bfbc0ef665e26561dd6020f399)
            check_type(argname="argument text", value=text, expected_type=type_hints["text"])
            check_type(argname="argument add_to_summary", value=add_to_summary, expected_type=type_hints["add_to_summary"])
            check_type(argname="argument add_to_alarm", value=add_to_alarm, expected_type=type_hints["add_to_alarm"])
        return typing.cast("MonitoringFacade", jsii.invoke(self, "addMediumHeader", [text, add_to_summary, add_to_alarm]))

    @jsii.member(jsii_name="addSegment")
    def add_segment(
        self,
        segment: IDashboardSegment,
        *,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''(experimental) Adds a dashboard segment to go on one of the {@link DefaultDashboards}.

        :param segment: segment to add.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e97eb86841d101df2335f36e088d0dbf9eaea1465ac960bc689cca33956a5da8)
            check_type(argname="argument segment", value=segment, expected_type=type_hints["segment"])
        override_props = MonitoringDashboardsOverrideProps(
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "addSegment", [segment, override_props]))

    @jsii.member(jsii_name="addSmallHeader")
    def add_small_header(
        self,
        text: builtins.str,
        add_to_summary: typing.Optional[builtins.bool] = None,
        add_to_alarm: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param text: -
        :param add_to_summary: -
        :param add_to_alarm: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d1f79507132db1a6e5aa48d09fa1c0bc369befa6cfc02df77f86f6e1deaf32f)
            check_type(argname="argument text", value=text, expected_type=type_hints["text"])
            check_type(argname="argument add_to_summary", value=add_to_summary, expected_type=type_hints["add_to_summary"])
            check_type(argname="argument add_to_alarm", value=add_to_alarm, expected_type=type_hints["add_to_alarm"])
        return typing.cast("MonitoringFacade", jsii.invoke(self, "addSmallHeader", [text, add_to_summary, add_to_alarm]))

    @jsii.member(jsii_name="addWidget")
    def add_widget(
        self,
        widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
        add_to_summary: typing.Optional[builtins.bool] = None,
        add_to_alarm: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param widget: -
        :param add_to_summary: -
        :param add_to_alarm: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6c19f8fc0852248da01ee21d56ff49c5bca5e9939d7ed5f0bd931aee21f543d2)
            check_type(argname="argument widget", value=widget, expected_type=type_hints["widget"])
            check_type(argname="argument add_to_summary", value=add_to_summary, expected_type=type_hints["add_to_summary"])
            check_type(argname="argument add_to_alarm", value=add_to_alarm, expected_type=type_hints["add_to_alarm"])
        return typing.cast("MonitoringFacade", jsii.invoke(self, "addWidget", [widget, add_to_summary, add_to_alarm]))

    @jsii.member(jsii_name="createAlarmFactory")
    def create_alarm_factory(self, alarm_name_prefix: builtins.str) -> AlarmFactory:
        '''(experimental) Creates a new alarm factory.

        Alarms created will be named with the given prefix, unless a local name override is present.

        :param alarm_name_prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3a9b47b86692d73d9bf9c4437266c4d331e9b66c18b512bd06ab96aa0d68e00)
            check_type(argname="argument alarm_name_prefix", value=alarm_name_prefix, expected_type=type_hints["alarm_name_prefix"])
        return typing.cast(AlarmFactory, jsii.invoke(self, "createAlarmFactory", [alarm_name_prefix]))

    @jsii.member(jsii_name="createAwsConsoleUrlFactory")
    def create_aws_console_url_factory(self) -> AwsConsoleUrlFactory:
        '''(experimental) Creates a new factory that creates AWS Console URLs.

        :stability: experimental
        '''
        return typing.cast(AwsConsoleUrlFactory, jsii.invoke(self, "createAwsConsoleUrlFactory", []))

    @jsii.member(jsii_name="createCompositeAlarmUsingDisambiguator")
    def create_composite_alarm_using_disambiguator(
        self,
        alarm_disambiguator: builtins.str,
        *,
        disambiguator: builtins.str,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
        actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        alarm_name_suffix: typing.Optional[builtins.str] = None,
        composite_operator: typing.Optional[CompositeAlarmOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        runbook_link: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm]:
        '''(experimental) Finds a subset of created alarms that are marked by a specific disambiguator and creates a composite alarm.

        This composite alarm is created with an 'OR' condition, so it triggers with any child alarm.
        NOTE: This composite alarm is not added among other alarms, so it is not returned by createdAlarms() calls.

        :param alarm_disambiguator: disambiguator to filter alarms by.
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param actions_suppressor: (experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state. Default: - no suppressor alarm
        :param actions_suppressor_extension_period: (experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param actions_suppressor_wait_period: (experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible. Default: - no description
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique. Default: - no suffix
        :param composite_operator: (experimental) Logical operator used to aggregate the status individual alarms. Default: - OR
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c56c0d362d0a9bbae754fdd10bfed41d8ca4e5da9c6da62e96bf804c5a86485e)
            check_type(argname="argument alarm_disambiguator", value=alarm_disambiguator, expected_type=type_hints["alarm_disambiguator"])
        props = AddCompositeAlarmProps(
            disambiguator=disambiguator,
            action_override=action_override,
            actions_enabled=actions_enabled,
            actions_suppressor=actions_suppressor,
            actions_suppressor_extension_period=actions_suppressor_extension_period,
            actions_suppressor_wait_period=actions_suppressor_wait_period,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description=alarm_description,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            alarm_name_suffix=alarm_name_suffix,
            composite_operator=composite_operator,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            fill_alarm_range=fill_alarm_range,
            runbook_link=runbook_link,
        )

        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm], jsii.invoke(self, "createCompositeAlarmUsingDisambiguator", [alarm_disambiguator, props]))

    @jsii.member(jsii_name="createCompositeAlarmUsingTag")
    def create_composite_alarm_using_tag(
        self,
        custom_tag: builtins.str,
        *,
        disambiguator: builtins.str,
        action_override: typing.Optional[IAlarmActionStrategy] = None,
        actions_enabled: typing.Optional[builtins.bool] = None,
        actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
        actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
        alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
        alarm_description: typing.Optional[builtins.str] = None,
        alarm_description_override: typing.Optional[builtins.str] = None,
        alarm_name_override: typing.Optional[builtins.str] = None,
        alarm_name_suffix: typing.Optional[builtins.str] = None,
        composite_operator: typing.Optional[CompositeAlarmOperator] = None,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string_override: typing.Optional[builtins.str] = None,
        documentation_link: typing.Optional[builtins.str] = None,
        fill_alarm_range: typing.Optional[builtins.bool] = None,
        runbook_link: typing.Optional[builtins.str] = None,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm]:
        '''(experimental) Finds a subset of created alarms that are marked by a specific custom tag and creates a composite alarm.

        This composite alarm is created with an 'OR' condition, so it triggers with any child alarm.
        NOTE: This composite alarm is not added among other alarms, so it is not returned by createdAlarms() calls.

        :param custom_tag: tag to filter alarms by.
        :param disambiguator: (experimental) Disambiguator is a string that differentiates this alarm from other similar ones.
        :param action_override: (experimental) Allows to override the default action strategy. Default: - default action will be used
        :param actions_enabled: (experimental) Enables the configured CloudWatch alarm ticketing actions. Default: - the same as monitoring facade default
        :param actions_suppressor: (experimental) Actions will be suppressed if the suppressor alarm is in the ALARM state. Default: - no suppressor alarm
        :param actions_suppressor_extension_period: (experimental) The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param actions_suppressor_wait_period: (experimental) The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state. After this time, the composite alarm performs its actions. Default: - 60 seconds
        :param alarm_dedupe_string_suffix: (experimental) If this is defined, the default resource-specific alarm dedupe string will be set and this will be added as a suffix. This allows you to specify the same dedupe string for a family of alarms. Cannot be defined at the same time as alarmDedupeStringOverride. Default: - undefined (no suffix)
        :param alarm_description: (experimental) Alarm description is included in the ticket and therefore should describe what happened, with as much context as possible. Default: - no description
        :param alarm_description_override: (experimental) A text included in the generated ticket description body, which fully replaces the generated text. Default: - default auto-generated content only
        :param alarm_name_override: (experimental) If this is defined, the alarm name is set to this exact value. Please be aware that you need to specify prefix for different stages (Beta, Prod...) and realms (EU, NA...) manually.
        :param alarm_name_suffix: (experimental) Suffix added to base alarm name. Alarm names need to be unique. Default: - no suffix
        :param composite_operator: (experimental) Logical operator used to aggregate the status individual alarms. Default: - OR
        :param custom_params: (experimental) This allows user to attach custom parameters to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no parameters
        :param custom_tags: (experimental) This allows user to attach custom values to this alarm, which can later be accessed from the "useCreatedAlarms" method. Default: - no tags
        :param dedupe_string_override: (experimental) If this is defined, the alarm dedupe string is set to this exact value. Please be aware that you need to handle deduping for different stages (Beta, Prod...) and realms (EU, NA...) manually. Default: - undefined (no override)
        :param documentation_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added
        :param fill_alarm_range: (experimental) Indicates whether the alarming range of values should be highlighted in the widget. Default: - false
        :param runbook_link: (experimental) An optional link included in the generated ticket description body. Default: - no additional link will be added

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__511f45620cd8f0f55343b8add7f7223cace944a651177a3082197c53d0e0fa67)
            check_type(argname="argument custom_tag", value=custom_tag, expected_type=type_hints["custom_tag"])
        props = AddCompositeAlarmProps(
            disambiguator=disambiguator,
            action_override=action_override,
            actions_enabled=actions_enabled,
            actions_suppressor=actions_suppressor,
            actions_suppressor_extension_period=actions_suppressor_extension_period,
            actions_suppressor_wait_period=actions_suppressor_wait_period,
            alarm_dedupe_string_suffix=alarm_dedupe_string_suffix,
            alarm_description=alarm_description,
            alarm_description_override=alarm_description_override,
            alarm_name_override=alarm_name_override,
            alarm_name_suffix=alarm_name_suffix,
            composite_operator=composite_operator,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string_override=dedupe_string_override,
            documentation_link=documentation_link,
            fill_alarm_range=fill_alarm_range,
            runbook_link=runbook_link,
        )

        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.CompositeAlarm], jsii.invoke(self, "createCompositeAlarmUsingTag", [custom_tag, props]))

    @jsii.member(jsii_name="createdAlarmDashboard")
    def created_alarm_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :return: default alarms dashboard

        :deprecated: - prefer calling dashboardFactory.getDashboard directly.

        :stability: deprecated
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdAlarmDashboard", []))

    @jsii.member(jsii_name="createdAlarms")
    def created_alarms(self) -> typing.List[AlarmWithAnnotation]:
        '''(experimental) Returns the created alarms across all added segments that subclass {@link Monitoring} added up until now.

        :stability: experimental
        '''
        return typing.cast(typing.List[AlarmWithAnnotation], jsii.invoke(self, "createdAlarms", []))

    @jsii.member(jsii_name="createdAlarmsWithDisambiguator")
    def created_alarms_with_disambiguator(
        self,
        disambiguator: builtins.str,
    ) -> typing.List[AlarmWithAnnotation]:
        '''(experimental) Returns a subset of created alarms that are marked by a specific disambiguator.

        :param disambiguator: disambiguator to filter alarms by.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e7a30d23d64a95bc8a70b4f63c1f5af29d8f769f0f78f364244045ef10bf036)
            check_type(argname="argument disambiguator", value=disambiguator, expected_type=type_hints["disambiguator"])
        return typing.cast(typing.List[AlarmWithAnnotation], jsii.invoke(self, "createdAlarmsWithDisambiguator", [disambiguator]))

    @jsii.member(jsii_name="createdAlarmsWithTag")
    def created_alarms_with_tag(
        self,
        custom_tag: builtins.str,
    ) -> typing.List[AlarmWithAnnotation]:
        '''(experimental) Returns a subset of created alarms that are marked by a specific custom tag.

        :param custom_tag: tag to filter alarms by.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11a02d7d4ddfaedf045ac667fc31a518c626371c1c480b58786704f055e93095)
            check_type(argname="argument custom_tag", value=custom_tag, expected_type=type_hints["custom_tag"])
        return typing.cast(typing.List[AlarmWithAnnotation], jsii.invoke(self, "createdAlarmsWithTag", [custom_tag]))

    @jsii.member(jsii_name="createdDashboard")
    def created_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :return: default detail dashboard

        :deprecated: - prefer calling dashboardFactory.getDashboard directly.

        :stability: deprecated
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdDashboard", []))

    @jsii.member(jsii_name="createdMonitorings")
    def created_monitorings(self) -> typing.List[Monitoring]:
        '''(experimental) Returns the added segments that subclass {@link Monitoring}.

        :stability: experimental
        '''
        return typing.cast(typing.List[Monitoring], jsii.invoke(self, "createdMonitorings", []))

    @jsii.member(jsii_name="createdSummaryDashboard")
    def created_summary_dashboard(
        self,
    ) -> typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard]:
        '''
        :return: default summary dashboard

        :deprecated: - prefer calling dashboardFactory.getDashboard directly.

        :stability: deprecated
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Dashboard], jsii.invoke(self, "createdSummaryDashboard", []))

    @jsii.member(jsii_name="createMetricFactory")
    def create_metric_factory(self) -> MetricFactory:
        '''(experimental) Creates a new metric factory.

        :stability: experimental
        '''
        return typing.cast(MetricFactory, jsii.invoke(self, "createMetricFactory", []))

    @jsii.member(jsii_name="createWidgetFactory")
    def create_widget_factory(self) -> IWidgetFactory:
        '''(experimental) Creates a new widget factory.

        :stability: experimental
        '''
        return typing.cast(IWidgetFactory, jsii.invoke(self, "createWidgetFactory", []))

    @jsii.member(jsii_name="monitorApiGateway")
    def monitor_api_gateway(
        self,
        *,
        api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param api: (experimental) API to monitor.
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - prod
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = ApiGatewayMonitoringProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add4_xx_error_count_alarm=add4_xx_error_count_alarm,
            add4_xx_error_rate_alarm=add4_xx_error_rate_alarm,
            add5_xx_fault_count_alarm=add5_xx_fault_count_alarm,
            add5_xx_fault_rate_alarm=add5_xx_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_average_alarm=add_latency_average_alarm,
            add_latency_p100_alarm=add_latency_p100_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p70_alarm=add_latency_p70_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p95_alarm=add_latency_p95_alarm,
            add_latency_p9999_alarm=add_latency_p9999_alarm,
            add_latency_p999_alarm=add_latency_p999_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_latency_tm50_alarm=add_latency_tm50_alarm,
            add_latency_tm70_alarm=add_latency_tm70_alarm,
            add_latency_tm90_alarm=add_latency_tm90_alarm,
            add_latency_tm95_alarm=add_latency_tm95_alarm,
            add_latency_tm95_outlier_alarm=add_latency_tm95_outlier_alarm,
            add_latency_tm9999_alarm=add_latency_tm9999_alarm,
            add_latency_tm9999_outlier_alarm=add_latency_tm9999_outlier_alarm,
            add_latency_tm999_alarm=add_latency_tm999_alarm,
            add_latency_tm999_outlier_alarm=add_latency_tm999_outlier_alarm,
            add_latency_tm99_alarm=add_latency_tm99_alarm,
            add_latency_tm99_outlier_alarm=add_latency_tm99_outlier_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            latency_types_to_render=latency_types_to_render,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorApiGateway", [props]))

    @jsii.member(jsii_name="monitorApiGatewayV2HttpApi")
    def monitor_api_gateway_v2_http_api(
        self,
        *,
        api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param api: 
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - $default
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add4xx_count_alarm: 
        :param add4xx_rate_alarm: 
        :param add5xx_count_alarm: 
        :param add5xx_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_integration_latency_average_alarm: 
        :param add_integration_latency_p100_alarm: 
        :param add_integration_latency_p50_alarm: 
        :param add_integration_latency_p70_alarm: 
        :param add_integration_latency_p90_alarm: 
        :param add_integration_latency_p95_alarm: 
        :param add_integration_latency_p9999_alarm: 
        :param add_integration_latency_p999_alarm: 
        :param add_integration_latency_p99_alarm: 
        :param add_integration_latency_tm50_alarm: 
        :param add_integration_latency_tm70_alarm: 
        :param add_integration_latency_tm90_alarm: 
        :param add_integration_latency_tm95_alarm: 
        :param add_integration_latency_tm95_outlier_alarm: 
        :param add_integration_latency_tm9999_alarm: 
        :param add_integration_latency_tm9999_outlier_alarm: 
        :param add_integration_latency_tm999_alarm: 
        :param add_integration_latency_tm999_outlier_alarm: 
        :param add_integration_latency_tm99_alarm: 
        :param add_integration_latency_tm99_outlier_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = ApiGatewayV2HttpApiMonitoringProps(
            api=api,
            api_method=api_method,
            api_resource=api_resource,
            api_stage=api_stage,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add4xx_count_alarm=add4xx_count_alarm,
            add4xx_rate_alarm=add4xx_rate_alarm,
            add5xx_count_alarm=add5xx_count_alarm,
            add5xx_rate_alarm=add5xx_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_integration_latency_average_alarm=add_integration_latency_average_alarm,
            add_integration_latency_p100_alarm=add_integration_latency_p100_alarm,
            add_integration_latency_p50_alarm=add_integration_latency_p50_alarm,
            add_integration_latency_p70_alarm=add_integration_latency_p70_alarm,
            add_integration_latency_p90_alarm=add_integration_latency_p90_alarm,
            add_integration_latency_p95_alarm=add_integration_latency_p95_alarm,
            add_integration_latency_p9999_alarm=add_integration_latency_p9999_alarm,
            add_integration_latency_p999_alarm=add_integration_latency_p999_alarm,
            add_integration_latency_p99_alarm=add_integration_latency_p99_alarm,
            add_integration_latency_tm50_alarm=add_integration_latency_tm50_alarm,
            add_integration_latency_tm70_alarm=add_integration_latency_tm70_alarm,
            add_integration_latency_tm90_alarm=add_integration_latency_tm90_alarm,
            add_integration_latency_tm95_alarm=add_integration_latency_tm95_alarm,
            add_integration_latency_tm95_outlier_alarm=add_integration_latency_tm95_outlier_alarm,
            add_integration_latency_tm9999_alarm=add_integration_latency_tm9999_alarm,
            add_integration_latency_tm9999_outlier_alarm=add_integration_latency_tm9999_outlier_alarm,
            add_integration_latency_tm999_alarm=add_integration_latency_tm999_alarm,
            add_integration_latency_tm999_outlier_alarm=add_integration_latency_tm999_outlier_alarm,
            add_integration_latency_tm99_alarm=add_integration_latency_tm99_alarm,
            add_integration_latency_tm99_outlier_alarm=add_integration_latency_tm99_outlier_alarm,
            add_latency_average_alarm=add_latency_average_alarm,
            add_latency_p100_alarm=add_latency_p100_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p70_alarm=add_latency_p70_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p95_alarm=add_latency_p95_alarm,
            add_latency_p9999_alarm=add_latency_p9999_alarm,
            add_latency_p999_alarm=add_latency_p999_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_latency_tm50_alarm=add_latency_tm50_alarm,
            add_latency_tm70_alarm=add_latency_tm70_alarm,
            add_latency_tm90_alarm=add_latency_tm90_alarm,
            add_latency_tm95_alarm=add_latency_tm95_alarm,
            add_latency_tm95_outlier_alarm=add_latency_tm95_outlier_alarm,
            add_latency_tm9999_alarm=add_latency_tm9999_alarm,
            add_latency_tm9999_outlier_alarm=add_latency_tm9999_outlier_alarm,
            add_latency_tm999_alarm=add_latency_tm999_alarm,
            add_latency_tm999_outlier_alarm=add_latency_tm999_outlier_alarm,
            add_latency_tm99_alarm=add_latency_tm99_alarm,
            add_latency_tm99_outlier_alarm=add_latency_tm99_outlier_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            latency_types_to_render=latency_types_to_render,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorApiGatewayV2HttpApi", [props]))

    @jsii.member(jsii_name="monitorAppSyncApi")
    def monitor_app_sync_api(
        self,
        *,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param api: (experimental) the GraphQL API to monitor.
        :param fill_tps_with_zeroes: (experimental) whether the TPS should be filled with zeroes. Default: - true
        :param rate_computation_method: (experimental) method to compute TPS. Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = AppSyncMonitoringProps(
            add4_xx_error_count_alarm=add4_xx_error_count_alarm,
            add4_xx_error_rate_alarm=add4_xx_error_rate_alarm,
            add5_xx_fault_count_alarm=add5_xx_fault_count_alarm,
            add5_xx_fault_rate_alarm=add5_xx_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            api=api,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorAppSyncApi", [props]))

    @jsii.member(jsii_name="monitorAuroraCluster")
    def monitor_aurora_cluster(
        self,
        *,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param add_cpu_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_serverless_database_capacity_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = AuroraClusterMonitoringProps(
            cluster=cluster,
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_max_serverless_database_capacity_alarm=add_max_serverless_database_capacity_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorAuroraCluster", [props]))

    @jsii.member(jsii_name="monitorAutoScalingGroup")
    def monitor_auto_scaling_group(
        self,
        *,
        auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param auto_scaling_group: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = AutoScalingGroupMonitoringProps(
            auto_scaling_group=auto_scaling_group,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorAutoScalingGroup", [props]))

    @jsii.member(jsii_name="monitorBilling")
    def monitor_billing(
        self,
        *,
        add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_total_cost_anomaly_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = BillingMonitoringProps(
            add_total_cost_anomaly_alarm=add_total_cost_anomaly_alarm,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorBilling", [props]))

    @jsii.member(jsii_name="monitorCertificate")
    def monitor_certificate(
        self,
        *,
        add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_days_to_expiry_alarm: 
        :param certificate: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = CertificateManagerMonitoringProps(
            add_days_to_expiry_alarm=add_days_to_expiry_alarm,
            certificate=certificate,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorCertificate", [props]))

    @jsii.member(jsii_name="monitorCloudFrontDistribution")
    def monitor_cloud_front_distribution(
        self,
        *,
        add_error4xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault5xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
        additional_metrics_enabled: typing.Optional[builtins.bool] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_error4xx_rate: 
        :param add_fault5xx_rate: 
        :param add_high_tps_alarm: 
        :param add_low_tps_alarm: 
        :param distribution: 
        :param additional_metrics_enabled: (experimental) Generate dashboard charts for additional CloudFront distribution metrics. To enable additional metrics on your CloudFront distribution, see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional Default: - true
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = CloudFrontDistributionMonitoringProps(
            add_error4xx_rate=add_error4xx_rate,
            add_fault5xx_rate=add_fault5xx_rate,
            add_high_tps_alarm=add_high_tps_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            distribution=distribution,
            additional_metrics_enabled=additional_metrics_enabled,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorCloudFrontDistribution", [props]))

    @jsii.member(jsii_name="monitorCodeBuildProject")
    def monitor_code_build_project(
        self,
        *,
        project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param project: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_build_count_alarm: 
        :param add_failed_build_rate_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = CodeBuildProjectMonitoringProps(
            project=project,
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_build_count_alarm=add_failed_build_count_alarm,
            add_failed_build_rate_alarm=add_failed_build_rate_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorCodeBuildProject", [props]))

    @jsii.member(jsii_name="monitorCustom")
    def monitor_custom(
        self,
        *,
        metric_groups: typing.Sequence[typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]]],
        description: typing.Optional[builtins.str] = None,
        description_widget_height: typing.Optional[jsii.Number] = None,
        height: typing.Optional[jsii.Number] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param metric_groups: (experimental) define metric groups and metrics inside them (each metric group represents a widget).
        :param description: (experimental) optional description of the whole section, in markdown. Default: - no description
        :param description_widget_height: (experimental) optional height of the description widget, so the content fits. Default: - minimum height (should fit one or two lines of text)
        :param height: (experimental) Height override. Default: - default height
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = CustomMonitoringProps(
            metric_groups=metric_groups,
            description=description,
            description_widget_height=description_widget_height,
            height=height,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorCustom", [props]))

    @jsii.member(jsii_name="monitorDocumentDbCluster")
    def monitor_document_db_cluster(
        self,
        *,
        cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param cluster: (experimental) database cluster.
        :param add_cpu_usage_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = DocumentDbMonitoringProps(
            cluster=cluster,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorDocumentDbCluster", [props]))

    @jsii.member(jsii_name="monitorDynamoTable")
    def monitor_dynamo_table(
        self,
        *,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
        add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param table: (experimental) table to monitor.
        :param billing_mode: (experimental) table billing mode. Default: - best effort auto-detection or PROVISIONED as a fallback
        :param add_average_successful_batch_get_item_latency_alarm: 
        :param add_average_successful_batch_write_item_latency_alarm: 
        :param add_average_successful_delete_item_latency_alarm: 
        :param add_average_successful_get_item_latency_alarm: 
        :param add_average_successful_get_records_latency_alarm: 
        :param add_average_successful_put_item_latency_alarm: 
        :param add_average_successful_query_latency_alarm: 
        :param add_average_successful_scan_latency_alarm: 
        :param add_average_successful_update_item_latency_alarm: 
        :param add_consumed_read_capacity_alarm: 
        :param add_consumed_write_capacity_alarm: 
        :param add_min_time_to_live_deleted_item_count_alarm: 
        :param add_read_throttled_events_count_alarm: 
        :param add_system_error_count_alarm: 
        :param add_write_throttled_events_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = DynamoTableMonitoringProps(
            table=table,
            billing_mode=billing_mode,
            add_average_successful_batch_get_item_latency_alarm=add_average_successful_batch_get_item_latency_alarm,
            add_average_successful_batch_write_item_latency_alarm=add_average_successful_batch_write_item_latency_alarm,
            add_average_successful_delete_item_latency_alarm=add_average_successful_delete_item_latency_alarm,
            add_average_successful_get_item_latency_alarm=add_average_successful_get_item_latency_alarm,
            add_average_successful_get_records_latency_alarm=add_average_successful_get_records_latency_alarm,
            add_average_successful_put_item_latency_alarm=add_average_successful_put_item_latency_alarm,
            add_average_successful_query_latency_alarm=add_average_successful_query_latency_alarm,
            add_average_successful_scan_latency_alarm=add_average_successful_scan_latency_alarm,
            add_average_successful_update_item_latency_alarm=add_average_successful_update_item_latency_alarm,
            add_consumed_read_capacity_alarm=add_consumed_read_capacity_alarm,
            add_consumed_write_capacity_alarm=add_consumed_write_capacity_alarm,
            add_min_time_to_live_deleted_item_count_alarm=add_min_time_to_live_deleted_item_count_alarm,
            add_read_throttled_events_count_alarm=add_read_throttled_events_count_alarm,
            add_system_error_count_alarm=add_system_error_count_alarm,
            add_write_throttled_events_count_alarm=add_write_throttled_events_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorDynamoTable", [props]))

    @jsii.member(jsii_name="monitorDynamoTableGlobalSecondaryIndex")
    def monitor_dynamo_table_global_secondary_index(
        self,
        *,
        add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        global_secondary_index_name: builtins.str,
        table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_read_throttled_events_count_alarm: 
        :param add_write_throttled_events_count_alarm: 
        :param global_secondary_index_name: 
        :param table: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = DynamoTableGlobalSecondaryIndexMonitoringProps(
            add_read_throttled_events_count_alarm=add_read_throttled_events_count_alarm,
            add_write_throttled_events_count_alarm=add_write_throttled_events_count_alarm,
            global_secondary_index_name=global_secondary_index_name,
            table=table,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorDynamoTableGlobalSecondaryIndex", [props]))

    @jsii.member(jsii_name="monitorEc2ApplicationLoadBalancer")
    def monitor_ec2_application_load_balancer(
        self,
        *,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param application_load_balancer: 
        :param application_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = Ec2ApplicationLoadBalancerMonitoringProps(
            ec2_service=ec2_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            application_load_balancer=application_load_balancer,
            application_target_group=application_target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorEc2ApplicationLoadBalancer", [props]))

    @jsii.member(jsii_name="monitorEC2Instances")
    def monitor_ec2_instances(
        self,
        *,
        auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
        instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param auto_scaling_group: (experimental) Auto-Scaling Group to monitor. Default: - no Auto-Scaling Group filter
        :param instance_ids: (experimental) Selected IDs of EC2 instances to monitor. Default: - no instance filter
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = EC2MonitoringProps(
            auto_scaling_group=auto_scaling_group,
            instance_ids=instance_ids,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorEC2Instances", [props]))

    @jsii.member(jsii_name="monitorEc2NetworkLoadBalancer")
    def monitor_ec2_network_load_balancer(
        self,
        *,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param network_load_balancer: 
        :param network_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = Ec2NetworkLoadBalancerMonitoringProps(
            ec2_service=ec2_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            network_load_balancer=network_load_balancer,
            network_target_group=network_target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorEc2NetworkLoadBalancer", [props]))

    @jsii.member(jsii_name="monitorEc2Service")
    def monitor_ec2_service(
        self,
        *,
        ec2_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedEc2Service, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedEc2Service],
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param ec2_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = Ec2ServiceMonitoringProps(
            ec2_service=ec2_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorEc2Service", [props]))

    @jsii.member(jsii_name="monitorElastiCacheCluster")
    def monitor_elasti_cache_cluster(
        self,
        *,
        cluster_id: typing.Optional[builtins.str] = None,
        cluster_type: ElastiCacheClusterType,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param cluster_id: (experimental) Cluster to monitor. Default: - monitor all clusters
        :param cluster_type: (experimental) Cluster type (needed, since each type has their own specific metrics).
        :param add_cpu_usage_alarm: (experimental) Add CPU usage alarm (useful for all clusterTypes including Redis).
        :param add_max_evicted_items_count_alarm: (experimental) Add alarm on number of evicted items.
        :param add_max_items_count_alarm: (experimental) Add alarm on total number of items.
        :param add_max_used_swap_memory_alarm: (experimental) Add alarm on amount of used swap memory.
        :param add_min_freeable_memory_alarm: (experimental) Add alarm on amount of freeable memory.
        :param add_redis_engine_cpu_usage_alarm: (experimental) Add Redis engine CPU usage alarm. It is recommended to monitor CPU utilization with ``addCpuUsageAlarm`` as well for hosts with two vCPUs or less.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = ElastiCacheClusterMonitoringProps(
            cluster_id=cluster_id,
            cluster_type=cluster_type,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_max_evicted_items_count_alarm=add_max_evicted_items_count_alarm,
            add_max_items_count_alarm=add_max_items_count_alarm,
            add_max_used_swap_memory_alarm=add_max_used_swap_memory_alarm,
            add_min_freeable_memory_alarm=add_min_freeable_memory_alarm,
            add_redis_engine_cpu_usage_alarm=add_redis_engine_cpu_usage_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorElastiCacheCluster", [props]))

    @jsii.member(jsii_name="monitorElasticsearchCluster")
    def monitor_elasticsearch_cluster(
        self,
        *,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add_cluster_automated_snapshot_failure_alarm: 
        :param add_cluster_index_writes_blocked_alarm: 
        :param add_cluster_node_count_alarm: 
        :param add_cluster_status_alarm: 
        :param add_cpu_space_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_indexing_latency_p50_alarm: 
        :param add_indexing_latency_p90_alarm: 
        :param add_indexing_latency_p99_alarm: 
        :param add_jvm_memory_pressure_alarm: 
        :param add_kms_key_error_alarm: 
        :param add_kms_key_inaccessible_alarm: 
        :param add_master_cpu_space_usage_alarm: 
        :param add_master_jvm_memory_pressure_alarm: 
        :param add_search_latency_p50_alarm: 
        :param add_search_latency_p90_alarm: 
        :param add_search_latency_p99_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = OpenSearchClusterMonitoringProps(
            domain=domain,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add_cluster_automated_snapshot_failure_alarm=add_cluster_automated_snapshot_failure_alarm,
            add_cluster_index_writes_blocked_alarm=add_cluster_index_writes_blocked_alarm,
            add_cluster_node_count_alarm=add_cluster_node_count_alarm,
            add_cluster_status_alarm=add_cluster_status_alarm,
            add_cpu_space_usage_alarm=add_cpu_space_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_indexing_latency_p50_alarm=add_indexing_latency_p50_alarm,
            add_indexing_latency_p90_alarm=add_indexing_latency_p90_alarm,
            add_indexing_latency_p99_alarm=add_indexing_latency_p99_alarm,
            add_jvm_memory_pressure_alarm=add_jvm_memory_pressure_alarm,
            add_kms_key_error_alarm=add_kms_key_error_alarm,
            add_kms_key_inaccessible_alarm=add_kms_key_inaccessible_alarm,
            add_master_cpu_space_usage_alarm=add_master_cpu_space_usage_alarm,
            add_master_jvm_memory_pressure_alarm=add_master_jvm_memory_pressure_alarm,
            add_search_latency_p50_alarm=add_search_latency_p50_alarm,
            add_search_latency_p90_alarm=add_search_latency_p90_alarm,
            add_search_latency_p99_alarm=add_search_latency_p99_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorElasticsearchCluster", [props]))

    @jsii.member(jsii_name="monitorFargateApplicationLoadBalancer")
    def monitor_fargate_application_load_balancer(
        self,
        *,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
        application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param application_load_balancer: 
        :param application_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = FargateApplicationLoadBalancerMonitoringProps(
            fargate_service=fargate_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            application_load_balancer=application_load_balancer,
            application_target_group=application_target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorFargateApplicationLoadBalancer", [props]))

    @jsii.member(jsii_name="monitorFargateNetworkLoadBalancer")
    def monitor_fargate_network_load_balancer(
        self,
        *,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param network_load_balancer: 
        :param network_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = FargateNetworkLoadBalancerMonitoringProps(
            fargate_service=fargate_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            network_load_balancer=network_load_balancer,
            network_target_group=network_target_group,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorFargateNetworkLoadBalancer", [props]))

    @jsii.member(jsii_name="monitorFargateService")
    def monitor_fargate_service(
        self,
        *,
        fargate_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedFargateService, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedFargateService],
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param fargate_service: 
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param invert_load_balancer_task_count_metrics_statistics: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertLoadBalancerTaskCountMetricsStatistics`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertLoadBalancerTaskCountMetricsStatistics`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = FargateServiceMonitoringProps(
            fargate_service=fargate_service,
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            invert_load_balancer_task_count_metrics_statistics=invert_load_balancer_task_count_metrics_statistics,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorFargateService", [props]))

    @jsii.member(jsii_name="monitorFluentBit")
    def monitor_fluent_bit(
        self,
        *,
        log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
        create_optional_metric_filters: typing.Optional[builtins.bool] = None,
        namespace: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param log_group: (experimental) Log group that contains FluentBit metric logs.
        :param create_optional_metric_filters: (experimental) Metrics for input bytes total, output bytes total and output records total are not shown on default dashboard. If you want to get MetricFilters created to have those metrics present in CloudWatch set this flag to true Default: false
        :param namespace: (experimental) Namespace that metrics will be emitted to. Default: metric factory default
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = FluentBitMonitoringProps(
            log_group=log_group,
            create_optional_metric_filters=create_optional_metric_filters,
            namespace=namespace,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorFluentBit", [props]))

    @jsii.member(jsii_name="monitorGlueJob")
    def monitor_glue_job(
        self,
        *,
        add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        job_name: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_failed_task_count_alarm: 
        :param add_failed_task_rate_alarm: 
        :param add_killed_task_count_alarm: 
        :param add_killed_task_rate_alarm: 
        :param job_name: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = GlueJobMonitoringProps(
            add_failed_task_count_alarm=add_failed_task_count_alarm,
            add_failed_task_rate_alarm=add_failed_task_rate_alarm,
            add_killed_task_count_alarm=add_killed_task_count_alarm,
            add_killed_task_rate_alarm=add_killed_task_rate_alarm,
            job_name=job_name,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorGlueJob", [props]))

    @jsii.member(jsii_name="monitorKinesisDataAnalytics")
    def monitor_kinesis_data_analytics(
        self,
        *,
        application: builtins.str,
        add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param application: 
        :param add_downtime_alarm: 
        :param add_full_restart_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = KinesisDataAnalyticsMonitoringProps(
            application=application,
            add_downtime_alarm=add_downtime_alarm,
            add_full_restart_count_alarm=add_full_restart_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorKinesisDataAnalytics", [props]))

    @jsii.member(jsii_name="monitorKinesisDataStream")
    def monitor_kinesis_data_stream(
        self,
        *,
        stream_name: builtins.str,
        add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param stream_name: 
        :param add_iterator_max_age_alarm: 
        :param add_put_records_failed_alarm: 
        :param add_put_records_throttled_alarm: 
        :param add_read_provisioned_throughput_exceeded_alarm: 
        :param add_throttled_records_alarm: 
        :param add_write_provisioned_throughput_exceeded_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = KinesisDataStreamMonitoringProps(
            stream_name=stream_name,
            add_iterator_max_age_alarm=add_iterator_max_age_alarm,
            add_put_records_failed_alarm=add_put_records_failed_alarm,
            add_put_records_throttled_alarm=add_put_records_throttled_alarm,
            add_read_provisioned_throughput_exceeded_alarm=add_read_provisioned_throughput_exceeded_alarm,
            add_throttled_records_alarm=add_throttled_records_alarm,
            add_write_provisioned_throughput_exceeded_alarm=add_write_provisioned_throughput_exceeded_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorKinesisDataStream", [props]))

    @jsii.member(jsii_name="monitorKinesisFirehose")
    def monitor_kinesis_firehose(
        self,
        *,
        delivery_stream_name: builtins.str,
        add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param delivery_stream_name: 
        :param add_incoming_bytes_exceed_threshold_alarm: 
        :param add_incoming_put_requests_exceed_threshold_alarm: 
        :param add_incoming_records_exceed_threshold_alarm: 
        :param add_records_throttled_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = KinesisFirehoseMonitoringProps(
            delivery_stream_name=delivery_stream_name,
            add_incoming_bytes_exceed_threshold_alarm=add_incoming_bytes_exceed_threshold_alarm,
            add_incoming_put_requests_exceed_threshold_alarm=add_incoming_put_requests_exceed_threshold_alarm,
            add_incoming_records_exceed_threshold_alarm=add_incoming_records_exceed_threshold_alarm,
            add_records_throttled_alarm=add_records_throttled_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorKinesisFirehose", [props]))

    @jsii.member(jsii_name="monitorLambdaFunction")
    def monitor_lambda_function(
        self,
        *,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        lambda_insights_enabled: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        is_iterator: typing.Optional[builtins.bool] = None,
        is_offset_lag: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param lambda_function: 
        :param fill_tps_with_zeroes: Default: - true
        :param lambda_insights_enabled: (experimental) Generate dashboard charts for Lambda Insights metrics. To enable Lambda Insights on your Lambda function, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-Getting-Started-clouddevelopmentkit.html Default: - false
        :param rate_computation_method: Default: - average
        :param add_concurrent_executions_count_alarm: 
        :param add_enhanced_monitoring_avg_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_avg_memory_utilization_alarm: 
        :param add_enhanced_monitoring_max_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_max_memory_utilization_alarm: 
        :param add_enhanced_monitoring_p90_cpu_total_time_alarm: 
        :param add_enhanced_monitoring_p90_memory_utilization_alarm: 
        :param add_fault_count_alarm: 
        :param add_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param add_max_iterator_age_alarm: 
        :param add_max_latency_alarm: 
        :param add_max_offset_lag_alarm: 
        :param add_min_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_count_alarm: 
        :param add_provisioned_concurrency_spillover_invocations_rate_alarm: 
        :param add_throttles_count_alarm: 
        :param add_throttles_rate_alarm: 
        :param is_iterator: (experimental) Indicates that the Lambda function handles an event source (e.g. DynamoDB event stream). This impacts what widgets are shown, as well as validates the ability to use addMaxIteratorAgeAlarm. Default: - true
        :param is_offset_lag: (experimental) Indicates that the Lambda function handles an event source which uses offsets for records (e.g. Kafka streams). This impacts what widgets are shown, as well as validates the ability to use addMaxOffsetLagAlarm. Default: - false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = LambdaFunctionMonitoringProps(
            lambda_function=lambda_function,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            lambda_insights_enabled=lambda_insights_enabled,
            rate_computation_method=rate_computation_method,
            add_concurrent_executions_count_alarm=add_concurrent_executions_count_alarm,
            add_enhanced_monitoring_avg_cpu_total_time_alarm=add_enhanced_monitoring_avg_cpu_total_time_alarm,
            add_enhanced_monitoring_avg_memory_utilization_alarm=add_enhanced_monitoring_avg_memory_utilization_alarm,
            add_enhanced_monitoring_max_cpu_total_time_alarm=add_enhanced_monitoring_max_cpu_total_time_alarm,
            add_enhanced_monitoring_max_memory_utilization_alarm=add_enhanced_monitoring_max_memory_utilization_alarm,
            add_enhanced_monitoring_p90_cpu_total_time_alarm=add_enhanced_monitoring_p90_cpu_total_time_alarm,
            add_enhanced_monitoring_p90_memory_utilization_alarm=add_enhanced_monitoring_p90_memory_utilization_alarm,
            add_fault_count_alarm=add_fault_count_alarm,
            add_fault_rate_alarm=add_fault_rate_alarm,
            add_high_tps_alarm=add_high_tps_alarm,
            add_latency_p50_alarm=add_latency_p50_alarm,
            add_latency_p90_alarm=add_latency_p90_alarm,
            add_latency_p99_alarm=add_latency_p99_alarm,
            add_low_tps_alarm=add_low_tps_alarm,
            add_max_iterator_age_alarm=add_max_iterator_age_alarm,
            add_max_latency_alarm=add_max_latency_alarm,
            add_max_offset_lag_alarm=add_max_offset_lag_alarm,
            add_min_invocations_count_alarm=add_min_invocations_count_alarm,
            add_provisioned_concurrency_spillover_invocations_count_alarm=add_provisioned_concurrency_spillover_invocations_count_alarm,
            add_provisioned_concurrency_spillover_invocations_rate_alarm=add_provisioned_concurrency_spillover_invocations_rate_alarm,
            add_throttles_count_alarm=add_throttles_count_alarm,
            add_throttles_rate_alarm=add_throttles_rate_alarm,
            is_iterator=is_iterator,
            is_offset_lag=is_offset_lag,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorLambdaFunction", [props]))

    @jsii.member(jsii_name="monitorLog")
    def monitor_log(
        self,
        *,
        add_max_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        limit: typing.Optional[jsii.Number] = None,
        pattern: typing.Optional[builtins.str] = None,
        title: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        log_group_name: builtins.str,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_max_incoming_logs_alarm: 
        :param add_min_incoming_logs_alarm: 
        :param limit: (experimental) Maximum number of log messages to search for. Default: - 10
        :param pattern: (experimental) Pattern to search for, e.g. "ERROR".
        :param title: (experimental) Widget title. Default: - auto-generated title based on the pattern and limit
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param log_group_name: (experimental) Name of the log group to monitor.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = LogMonitoringProps(
            add_max_incoming_logs_alarm=add_max_incoming_logs_alarm,
            add_min_incoming_logs_alarm=add_min_incoming_logs_alarm,
            limit=limit,
            pattern=pattern,
            title=title,
            use_created_alarms=use_created_alarms,
            log_group_name=log_group_name,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorLog", [props]))

    @jsii.member(jsii_name="monitorNetworkLoadBalancer")
    def monitor_network_load_balancer(
        self,
        *,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 
        :param network_load_balancer: 
        :param network_target_group: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = NetworkLoadBalancerMonitoringProps(
            add_healthy_task_count_alarm=add_healthy_task_count_alarm,
            add_healthy_task_percent_alarm=add_healthy_task_percent_alarm,
            add_min_processed_bytes_alarm=add_min_processed_bytes_alarm,
            add_unhealthy_task_count_alarm=add_unhealthy_task_count_alarm,
            network_load_balancer=network_load_balancer,
            network_target_group=network_target_group,
            use_created_alarms=use_created_alarms,
            invert_statistics_of_task_count_enabled=invert_statistics_of_task_count_enabled,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorNetworkLoadBalancer", [props]))

    @jsii.member(jsii_name="monitorOpenSearchCluster")
    def monitor_open_search_cluster(
        self,
        *,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param add_cluster_automated_snapshot_failure_alarm: 
        :param add_cluster_index_writes_blocked_alarm: 
        :param add_cluster_node_count_alarm: 
        :param add_cluster_status_alarm: 
        :param add_cpu_space_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_indexing_latency_p50_alarm: 
        :param add_indexing_latency_p90_alarm: 
        :param add_indexing_latency_p99_alarm: 
        :param add_jvm_memory_pressure_alarm: 
        :param add_kms_key_error_alarm: 
        :param add_kms_key_inaccessible_alarm: 
        :param add_master_cpu_space_usage_alarm: 
        :param add_master_jvm_memory_pressure_alarm: 
        :param add_search_latency_p50_alarm: 
        :param add_search_latency_p90_alarm: 
        :param add_search_latency_p99_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = OpenSearchClusterMonitoringProps(
            domain=domain,
            fill_tps_with_zeroes=fill_tps_with_zeroes,
            rate_computation_method=rate_computation_method,
            add_cluster_automated_snapshot_failure_alarm=add_cluster_automated_snapshot_failure_alarm,
            add_cluster_index_writes_blocked_alarm=add_cluster_index_writes_blocked_alarm,
            add_cluster_node_count_alarm=add_cluster_node_count_alarm,
            add_cluster_status_alarm=add_cluster_status_alarm,
            add_cpu_space_usage_alarm=add_cpu_space_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_indexing_latency_p50_alarm=add_indexing_latency_p50_alarm,
            add_indexing_latency_p90_alarm=add_indexing_latency_p90_alarm,
            add_indexing_latency_p99_alarm=add_indexing_latency_p99_alarm,
            add_jvm_memory_pressure_alarm=add_jvm_memory_pressure_alarm,
            add_kms_key_error_alarm=add_kms_key_error_alarm,
            add_kms_key_inaccessible_alarm=add_kms_key_inaccessible_alarm,
            add_master_cpu_space_usage_alarm=add_master_cpu_space_usage_alarm,
            add_master_jvm_memory_pressure_alarm=add_master_jvm_memory_pressure_alarm,
            add_search_latency_p50_alarm=add_search_latency_p50_alarm,
            add_search_latency_p90_alarm=add_search_latency_p90_alarm,
            add_search_latency_p99_alarm=add_search_latency_p99_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorOpenSearchCluster", [props]))

    @jsii.member(jsii_name="monitorQueueProcessingEc2Service")
    def monitor_queue_processing_ec2_service(
        self,
        *,
        ec2_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingEc2Service,
        add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param ec2_service: 
        :param add_dead_letter_queue_alarms: 
        :param add_queue_alarms: 
        :param add_service_alarms: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = QueueProcessingEc2ServiceMonitoringProps(
            ec2_service=ec2_service,
            add_dead_letter_queue_alarms=add_dead_letter_queue_alarms,
            add_queue_alarms=add_queue_alarms,
            add_service_alarms=add_service_alarms,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorQueueProcessingEc2Service", [props]))

    @jsii.member(jsii_name="monitorQueueProcessingFargateService")
    def monitor_queue_processing_fargate_service(
        self,
        *,
        fargate_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingFargateService,
        add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param fargate_service: 
        :param add_dead_letter_queue_alarms: 
        :param add_queue_alarms: 
        :param add_service_alarms: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = QueueProcessingFargateServiceMonitoringProps(
            fargate_service=fargate_service,
            add_dead_letter_queue_alarms=add_dead_letter_queue_alarms,
            add_queue_alarms=add_queue_alarms,
            add_service_alarms=add_service_alarms,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorQueueProcessingFargateService", [props]))

    @jsii.member(jsii_name="monitorRdsCluster")
    def monitor_rds_cluster(
        self,
        *,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = RdsClusterMonitoringProps(
            cluster=cluster,
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorRdsCluster", [props]))

    @jsii.member(jsii_name="monitorRdsInstance")
    def monitor_rds_instance(
        self,
        *,
        instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param instance: (experimental) database instance.
        :param add_cpu_usage_alarm: 
        :param add_free_storage_space_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = RdsInstanceMonitoringProps(
            instance=instance,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_free_storage_space_alarm=add_free_storage_space_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorRdsInstance", [props]))

    @jsii.member(jsii_name="monitorRedshiftCluster")
    def monitor_redshift_cluster(
        self,
        *,
        cluster_identifier: builtins.str,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param cluster_identifier: 
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_long_query_duration_alarm: 
        :param add_min_connection_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = RedshiftClusterMonitoringProps(
            cluster_identifier=cluster_identifier,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_disk_space_usage_alarm=add_disk_space_usage_alarm,
            add_max_connection_count_alarm=add_max_connection_count_alarm,
            add_max_long_query_duration_alarm=add_max_long_query_duration_alarm,
            add_min_connection_count_alarm=add_min_connection_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorRedshiftCluster", [props]))

    @jsii.member(jsii_name="monitorS3Bucket")
    def monitor_s3_bucket(
        self,
        *,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        storage_type: typing.Optional[StorageType] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param bucket: 
        :param storage_type: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = S3BucketMonitoringProps(
            bucket=bucket,
            storage_type=storage_type,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorS3Bucket", [props]))

    @jsii.member(jsii_name="monitorScope")
    def monitor_scope(
        self,
        scope: _constructs_77d1e7e8.Construct,
        *,
        acm: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        api_gateway_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        app_sync: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        aurora_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        auto_scaling_group: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        billing: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        cloud_front: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        code_build: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        document_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        dynamo_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        ec2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        elastic_cache: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        glue: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_analytics: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_data_stream: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        kinesis_firehose: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        lambda_: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        open_search: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        rds: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        rds_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        rds_instance: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        redshift: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        s3: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        secrets_manager: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        sns: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        sqs: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        step_functions: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        synthetics_canaries: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
        web_application_firewall_acl_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "MonitoringFacade":
        '''(experimental) Uses an aspect to automatically monitor all resources in the given scope.

        :param scope: Scope with resources to monitor.
        :param acm: 
        :param api_gateway: 
        :param api_gateway_v2: 
        :param app_sync: 
        :param aurora_cluster: 
        :param auto_scaling_group: 
        :param billing: 
        :param cloud_front: 
        :param code_build: 
        :param document_db: 
        :param dynamo_db: 
        :param ec2: 
        :param elastic_cache: 
        :param glue: 
        :param kinesis_data_analytics: 
        :param kinesis_data_stream: 
        :param kinesis_firehose: 
        :param lambda_: 
        :param open_search: 
        :param rds: 
        :param rds_cluster: 
        :param rds_instance: 
        :param redshift: 
        :param s3: 
        :param secrets_manager: 
        :param sns: 
        :param sqs: 
        :param step_functions: 
        :param synthetics_canaries: 
        :param web_application_firewall_acl_v2: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__54e7610248a417239be87b0d2e74510f3b0d17d10d14cbeead797637655bdc73)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        aspect_props = MonitoringAspectProps(
            acm=acm,
            api_gateway=api_gateway,
            api_gateway_v2=api_gateway_v2,
            app_sync=app_sync,
            aurora_cluster=aurora_cluster,
            auto_scaling_group=auto_scaling_group,
            billing=billing,
            cloud_front=cloud_front,
            code_build=code_build,
            document_db=document_db,
            dynamo_db=dynamo_db,
            ec2=ec2,
            elastic_cache=elastic_cache,
            glue=glue,
            kinesis_data_analytics=kinesis_data_analytics,
            kinesis_data_stream=kinesis_data_stream,
            kinesis_firehose=kinesis_firehose,
            lambda_=lambda_,
            open_search=open_search,
            rds=rds,
            rds_cluster=rds_cluster,
            rds_instance=rds_instance,
            redshift=redshift,
            s3=s3,
            secrets_manager=secrets_manager,
            sns=sns,
            sqs=sqs,
            step_functions=step_functions,
            synthetics_canaries=synthetics_canaries,
            web_application_firewall_acl_v2=web_application_firewall_acl_v2,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorScope", [scope, aspect_props]))

    @jsii.member(jsii_name="monitorSecretsManager")
    def monitor_secrets_manager(
        self,
        *,
        add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_change_in_secrets_alarm: 
        :param add_max_number_secrets_alarm: 
        :param add_min_number_secrets_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SecretsManagerMonitoringProps(
            add_change_in_secrets_alarm=add_change_in_secrets_alarm,
            add_max_number_secrets_alarm=add_max_number_secrets_alarm,
            add_min_number_secrets_alarm=add_min_number_secrets_alarm,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSecretsManager", [props]))

    @jsii.member(jsii_name="monitorSecretsManagerSecret")
    def monitor_secrets_manager_secret(
        self,
        *,
        secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
        add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        show_last_rotation_widget: typing.Optional[builtins.bool] = None,
        use_publisher: typing.Optional[IPublisherConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param secret: 
        :param add_days_since_last_change_alarm: 
        :param add_days_since_last_rotation_alarm: 
        :param show_last_rotation_widget: Default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.
        :param use_publisher: (experimental) Provides access to the underlying metrics publisher Lambda function. This may be useful if you want to monitor the function itself.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SecretsManagerSecretMonitoringProps(
            secret=secret,
            add_days_since_last_change_alarm=add_days_since_last_change_alarm,
            add_days_since_last_rotation_alarm=add_days_since_last_rotation_alarm,
            show_last_rotation_widget=show_last_rotation_widget,
            use_publisher=use_publisher,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSecretsManagerSecret", [props]))

    @jsii.member(jsii_name="monitorSimpleEc2Service")
    def monitor_simple_ec2_service(
        self,
        *,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param ec2_service: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SimpleEc2ServiceMonitoringProps(
            ec2_service=ec2_service,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSimpleEc2Service", [props]))

    @jsii.member(jsii_name="monitorSimpleFargateService")
    def monitor_simple_fargate_service(
        self,
        *,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param fargate_service: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SimpleFargateServiceMonitoringProps(
            fargate_service=fargate_service,
            use_created_alarms=use_created_alarms,
            add_cpu_usage_alarm=add_cpu_usage_alarm,
            add_ephermal_storage_usage_alarm=add_ephermal_storage_usage_alarm,
            add_memory_usage_alarm=add_memory_usage_alarm,
            add_running_task_count_alarm=add_running_task_count_alarm,
            max_auto_scaling_task_count=max_auto_scaling_task_count,
            min_auto_scaling_task_count=min_auto_scaling_task_count,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSimpleFargateService", [props]))

    @jsii.member(jsii_name="monitorSnsTopic")
    def monitor_sns_topic(
        self,
        *,
        topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param topic: 
        :param add_max_number_of_messages_published_alarm: 
        :param add_message_notifications_failed_alarm: 
        :param add_min_number_of_messages_published_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SnsTopicMonitoringProps(
            topic=topic,
            add_max_number_of_messages_published_alarm=add_max_number_of_messages_published_alarm,
            add_message_notifications_failed_alarm=add_message_notifications_failed_alarm,
            add_min_number_of_messages_published_alarm=add_min_number_of_messages_published_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSnsTopic", [props]))

    @jsii.member(jsii_name="monitorSqsQueue")
    def monitor_sqs_queue(
        self,
        *,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param queue: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SqsQueueMonitoringProps(
            queue=queue,
            account=account,
            region=region,
            add_queue_max_incoming_messages_alarm=add_queue_max_incoming_messages_alarm,
            add_queue_max_message_age_alarm=add_queue_max_message_age_alarm,
            add_queue_max_size_alarm=add_queue_max_size_alarm,
            add_queue_max_time_to_drain_messages_alarm=add_queue_max_time_to_drain_messages_alarm,
            add_queue_min_incoming_messages_alarm=add_queue_min_incoming_messages_alarm,
            add_queue_min_size_alarm=add_queue_min_size_alarm,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSqsQueue", [props]))

    @jsii.member(jsii_name="monitorSqsQueueWithDlq")
    def monitor_sqs_queue_with_dlq(
        self,
        *,
        dead_letter_queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        add_dead_letter_queue_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param dead_letter_queue: 
        :param add_dead_letter_queue_to_summary_dashboard: (experimental) Indicates whether the DLQ monitoring should be added to summary dashboard. Default: - true
        :param add_dead_letter_queue_max_incoming_messages_alarm: (experimental) Alarm on the number of messages added to a queue. Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ as a result of a failed processing attempt.
        :param add_dead_letter_queue_max_message_age_alarm: 
        :param add_dead_letter_queue_max_size_alarm: 
        :param queue: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SqsQueueMonitoringWithDlqProps(
            dead_letter_queue=dead_letter_queue,
            add_dead_letter_queue_to_summary_dashboard=add_dead_letter_queue_to_summary_dashboard,
            add_dead_letter_queue_max_incoming_messages_alarm=add_dead_letter_queue_max_incoming_messages_alarm,
            add_dead_letter_queue_max_message_age_alarm=add_dead_letter_queue_max_message_age_alarm,
            add_dead_letter_queue_max_size_alarm=add_dead_letter_queue_max_size_alarm,
            queue=queue,
            account=account,
            region=region,
            add_queue_max_incoming_messages_alarm=add_queue_max_incoming_messages_alarm,
            add_queue_max_message_age_alarm=add_queue_max_message_age_alarm,
            add_queue_max_size_alarm=add_queue_max_size_alarm,
            add_queue_max_time_to_drain_messages_alarm=add_queue_max_time_to_drain_messages_alarm,
            add_queue_min_incoming_messages_alarm=add_queue_min_incoming_messages_alarm,
            add_queue_min_size_alarm=add_queue_min_size_alarm,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSqsQueueWithDlq", [props]))

    @jsii.member(jsii_name="monitorStepFunction")
    def monitor_step_function(
        self,
        *,
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param state_machine: 
        :param rate_computation_method: Default: - average
        :param add_aborted_execution_count_alarm: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_execution_count_alarm: 
        :param add_failed_execution_rate_alarm: 
        :param add_min_started_execution_count_alarm: (experimental) Add minimum started execution count alarm for the stepfunctions.
        :param add_throttled_execution_count_alarm: 
        :param add_timed_out_execution_count_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = StepFunctionMonitoringProps(
            state_machine=state_machine,
            rate_computation_method=rate_computation_method,
            add_aborted_execution_count_alarm=add_aborted_execution_count_alarm,
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_execution_count_alarm=add_failed_execution_count_alarm,
            add_failed_execution_rate_alarm=add_failed_execution_rate_alarm,
            add_min_started_execution_count_alarm=add_min_started_execution_count_alarm,
            add_throttled_execution_count_alarm=add_throttled_execution_count_alarm,
            add_timed_out_execution_count_alarm=add_timed_out_execution_count_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorStepFunction", [props]))

    @jsii.member(jsii_name="monitorStepFunctionActivity")
    def monitor_step_function_activity(
        self,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_activities_count_alarm: 
        :param add_failed_activities_rate_alarm: 
        :param add_timed_out_activities_count_alarm: 
        :param activity: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = StepFunctionActivityMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_activities_count_alarm=add_failed_activities_count_alarm,
            add_failed_activities_rate_alarm=add_failed_activities_rate_alarm,
            add_timed_out_activities_count_alarm=add_timed_out_activities_count_alarm,
            activity=activity,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorStepFunctionActivity", [props]))

    @jsii.member(jsii_name="monitorStepFunctionLambdaIntegration")
    def monitor_step_function_lambda_integration(
        self,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_functions_count_alarm: 
        :param add_failed_functions_rate_alarm: 
        :param add_timed_out_functions_count_alarm: 
        :param lambda_function: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = StepFunctionLambdaIntegrationMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_functions_count_alarm=add_failed_functions_count_alarm,
            add_failed_functions_rate_alarm=add_failed_functions_rate_alarm,
            add_timed_out_functions_count_alarm=add_timed_out_functions_count_alarm,
            lambda_function=lambda_function,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorStepFunctionLambdaIntegration", [props]))

    @jsii.member(jsii_name="monitorStepFunctionServiceIntegration")
    def monitor_step_function_service_integration(
        self,
        *,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        service_integration_resource_arn: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_service_integrations_count_alarm: 
        :param add_failed_service_integrations_rate_alarm: 
        :param add_timed_out_service_integrations_count_alarm: 
        :param service_integration_resource_arn: 
        :param rate_computation_method: Default: - average
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = StepFunctionServiceIntegrationMonitoringProps(
            add_duration_p50_alarm=add_duration_p50_alarm,
            add_duration_p90_alarm=add_duration_p90_alarm,
            add_duration_p99_alarm=add_duration_p99_alarm,
            add_failed_service_integrations_count_alarm=add_failed_service_integrations_count_alarm,
            add_failed_service_integrations_rate_alarm=add_failed_service_integrations_rate_alarm,
            add_timed_out_service_integrations_count_alarm=add_timed_out_service_integrations_count_alarm,
            service_integration_resource_arn=service_integration_resource_arn,
            rate_computation_method=rate_computation_method,
            use_created_alarms=use_created_alarms,
            account=account,
            region=region,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorStepFunctionServiceIntegration", [props]))

    @jsii.member(jsii_name="monitorSyntheticsCanary")
    def monitor_synthetics_canary(
        self,
        *,
        canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param canary: (experimental) CloudWatch Canary to monitor.
        :param rate_computation_method: (experimental) Method used to calculate relative rates. Default: - average
        :param add4xx_error_count_alarm: 
        :param add4xx_error_rate_alarm: 
        :param add5xx_fault_count_alarm: 
        :param add5xx_fault_rate_alarm: 
        :param add_average_latency_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = SyntheticsCanaryMonitoringProps(
            canary=canary,
            rate_computation_method=rate_computation_method,
            add4xx_error_count_alarm=add4xx_error_count_alarm,
            add4xx_error_rate_alarm=add4xx_error_rate_alarm,
            add5xx_fault_count_alarm=add5xx_fault_count_alarm,
            add5xx_fault_rate_alarm=add5xx_fault_rate_alarm,
            add_average_latency_alarm=add_average_latency_alarm,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorSyntheticsCanary", [props]))

    @jsii.member(jsii_name="monitorWebApplicationFirewallAclV2")
    def monitor_web_application_firewall_acl_v2(
        self,
        *,
        add_blocked_requests_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_blocked_requests_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> "MonitoringFacade":
        '''
        :param add_blocked_requests_count_alarm: 
        :param add_blocked_requests_rate_alarm: 
        :param acl: (experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        props = WafV2MonitoringProps(
            add_blocked_requests_count_alarm=add_blocked_requests_count_alarm,
            add_blocked_requests_rate_alarm=add_blocked_requests_rate_alarm,
            acl=acl,
            account=account,
            region=region,
            use_created_alarms=use_created_alarms,
            alarm_friendly_name=alarm_friendly_name,
            human_readable_name=human_readable_name,
            local_alarm_name_prefix_override=local_alarm_name_prefix_override,
            add_to_alarm_dashboard=add_to_alarm_dashboard,
            add_to_detail_dashboard=add_to_detail_dashboard,
            add_to_summary_dashboard=add_to_summary_dashboard,
        )

        return typing.cast("MonitoringFacade", jsii.invoke(self, "monitorWebApplicationFirewallAclV2", [props]))

    @builtins.property
    @jsii.member(jsii_name="alarmFactoryDefaults")
    def _alarm_factory_defaults(self) -> AlarmFactoryDefaults:
        '''
        :stability: experimental
        '''
        return typing.cast(AlarmFactoryDefaults, jsii.get(self, "alarmFactoryDefaults"))

    @builtins.property
    @jsii.member(jsii_name="createdSegments")
    def _created_segments(
        self,
    ) -> typing.List[typing.Union[IDashboardSegment, IDynamicDashboardSegment]]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List[typing.Union[IDashboardSegment, IDynamicDashboardSegment]], jsii.get(self, "createdSegments"))

    @builtins.property
    @jsii.member(jsii_name="metricFactoryDefaults")
    def _metric_factory_defaults(self) -> MetricFactoryDefaults:
        '''
        :stability: experimental
        '''
        return typing.cast(MetricFactoryDefaults, jsii.get(self, "metricFactoryDefaults"))

    @builtins.property
    @jsii.member(jsii_name="dashboardFactory")
    def dashboard_factory(self) -> typing.Optional[IDynamicDashboardFactory]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[IDynamicDashboardFactory], jsii.get(self, "dashboardFactory"))


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.NameResolutionInput",
    jsii_struct_bases=[UserProvidedNames],
    name_mapping={
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "fallback_construct_name": "fallbackConstructName",
        "named_construct": "namedConstruct",
    },
)
class NameResolutionInput(UserProvidedNames):
    def __init__(
        self,
        *,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        fallback_construct_name: typing.Optional[builtins.str] = None,
        named_construct: typing.Optional[_constructs_77d1e7e8.IConstruct] = None,
    ) -> None:
        '''
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param fallback_construct_name: (experimental) Fallback name before we fallback to extracting name from the construct itself. This might be some construct reference, such is cluster ID, stream name, and so on. Default: - use namedConstruct to extract the name
        :param named_construct: (experimental) Construct that this naming strategy is naming. It is used as a last resort for naming.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c5c2bf61af593a718b0e529c0a4160380c5f6ff8d0cabc2055a5d614574570f)
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument fallback_construct_name", value=fallback_construct_name, expected_type=type_hints["fallback_construct_name"])
            check_type(argname="argument named_construct", value=named_construct, expected_type=type_hints["named_construct"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if fallback_construct_name is not None:
            self._values["fallback_construct_name"] = fallback_construct_name
        if named_construct is not None:
            self._values["named_construct"] = named_construct

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fallback_construct_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Fallback name before we fallback to extracting name from the construct itself.

        This might be some construct reference, such is cluster ID, stream name, and so on.

        :default: - use namedConstruct to extract the name

        :stability: experimental
        '''
        result = self._values.get("fallback_construct_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def named_construct(self) -> typing.Optional[_constructs_77d1e7e8.IConstruct]:
        '''(experimental) Construct that this naming strategy is naming.

        It is used as a last resort for naming.

        :stability: experimental
        '''
        result = self._values.get("named_construct")
        return typing.cast(typing.Optional[_constructs_77d1e7e8.IConstruct], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NameResolutionInput(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.NetworkLoadBalancerMonitoringProps",
    jsii_struct_bases=[NetworkLoadBalancerMetricFactoryProps, BaseMonitoringProps],
    name_mapping={
        "invert_statistics_of_task_count_enabled": "invertStatisticsOfTaskCountEnabled",
        "account": "account",
        "region": "region",
        "network_load_balancer": "networkLoadBalancer",
        "network_target_group": "networkTargetGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_healthy_task_count_alarm": "addHealthyTaskCountAlarm",
        "add_healthy_task_percent_alarm": "addHealthyTaskPercentAlarm",
        "add_min_processed_bytes_alarm": "addMinProcessedBytesAlarm",
        "add_unhealthy_task_count_alarm": "addUnhealthyTaskCountAlarm",
    },
)
class NetworkLoadBalancerMonitoringProps(
    NetworkLoadBalancerMetricFactoryProps,
    BaseMonitoringProps,
):
    def __init__(
        self,
        *,
        invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
        network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param invert_statistics_of_task_count_enabled: (experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``. When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored. When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored. ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics Default: false
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param network_load_balancer: 
        :param network_target_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_healthy_task_count_alarm: 
        :param add_healthy_task_percent_alarm: 
        :param add_min_processed_bytes_alarm: 
        :param add_unhealthy_task_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3bbeb164e5ee70ac1270c16c03141b85dfe6eb0f76b8768ba20c858c3754e27)
            check_type(argname="argument invert_statistics_of_task_count_enabled", value=invert_statistics_of_task_count_enabled, expected_type=type_hints["invert_statistics_of_task_count_enabled"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument network_load_balancer", value=network_load_balancer, expected_type=type_hints["network_load_balancer"])
            check_type(argname="argument network_target_group", value=network_target_group, expected_type=type_hints["network_target_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_healthy_task_count_alarm", value=add_healthy_task_count_alarm, expected_type=type_hints["add_healthy_task_count_alarm"])
            check_type(argname="argument add_healthy_task_percent_alarm", value=add_healthy_task_percent_alarm, expected_type=type_hints["add_healthy_task_percent_alarm"])
            check_type(argname="argument add_min_processed_bytes_alarm", value=add_min_processed_bytes_alarm, expected_type=type_hints["add_min_processed_bytes_alarm"])
            check_type(argname="argument add_unhealthy_task_count_alarm", value=add_unhealthy_task_count_alarm, expected_type=type_hints["add_unhealthy_task_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_load_balancer": network_load_balancer,
            "network_target_group": network_target_group,
        }
        if invert_statistics_of_task_count_enabled is not None:
            self._values["invert_statistics_of_task_count_enabled"] = invert_statistics_of_task_count_enabled
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_healthy_task_count_alarm is not None:
            self._values["add_healthy_task_count_alarm"] = add_healthy_task_count_alarm
        if add_healthy_task_percent_alarm is not None:
            self._values["add_healthy_task_percent_alarm"] = add_healthy_task_percent_alarm
        if add_min_processed_bytes_alarm is not None:
            self._values["add_min_processed_bytes_alarm"] = add_min_processed_bytes_alarm
        if add_unhealthy_task_count_alarm is not None:
            self._values["add_unhealthy_task_count_alarm"] = add_unhealthy_task_count_alarm

    @builtins.property
    def invert_statistics_of_task_count_enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Invert the statistics of ``HealthyHostCount`` and ``UnHealthyHostCount``.

        When ``invertStatisticsOfTaskCountEnabled`` is set to false, the minimum of ``HealthyHostCount`` and the maximum of ``UnHealthyHostCount`` are monitored.
        When ``invertStatisticsOfTaskCountEnabled`` is set to true, the maximum of ``HealthyHostCount`` and the minimum of ``UnHealthyHostCount`` are monitored.

        ``invertStatisticsOfTaskCountEnabled`` is recommended to set to true as per the guidelines at
        https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-cloudwatch-metrics.html#metric-statistics

        :default: false

        :stability: experimental
        '''
        result = self._values.get("invert_statistics_of_task_count_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_load_balancer(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_load_balancer")
        assert result is not None, "Required property 'network_load_balancer' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer, result)

    @builtins.property
    def network_target_group(
        self,
    ) -> _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("network_target_group")
        assert result is not None, "Required property 'network_target_group' is missing"
        return typing.cast(_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_healthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskCountThreshold]], result)

    @builtins.property
    def add_healthy_task_percent_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_healthy_task_percent_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HealthyTaskPercentThreshold]], result)

    @builtins.property
    def add_min_processed_bytes_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_processed_bytes_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinProcessedBytesThreshold]], result)

    @builtins.property
    def add_unhealthy_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_unhealthy_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UnhealthyTaskCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NetworkLoadBalancerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cluster_automated_snapshot_failure_alarm": "addClusterAutomatedSnapshotFailureAlarm",
        "add_cluster_index_writes_blocked_alarm": "addClusterIndexWritesBlockedAlarm",
        "add_cluster_node_count_alarm": "addClusterNodeCountAlarm",
        "add_cluster_status_alarm": "addClusterStatusAlarm",
        "add_cpu_space_usage_alarm": "addCpuSpaceUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_indexing_latency_p50_alarm": "addIndexingLatencyP50Alarm",
        "add_indexing_latency_p90_alarm": "addIndexingLatencyP90Alarm",
        "add_indexing_latency_p99_alarm": "addIndexingLatencyP99Alarm",
        "add_jvm_memory_pressure_alarm": "addJvmMemoryPressureAlarm",
        "add_kms_key_error_alarm": "addKmsKeyErrorAlarm",
        "add_kms_key_inaccessible_alarm": "addKmsKeyInaccessibleAlarm",
        "add_master_cpu_space_usage_alarm": "addMasterCpuSpaceUsageAlarm",
        "add_master_jvm_memory_pressure_alarm": "addMasterJvmMemoryPressureAlarm",
        "add_search_latency_p50_alarm": "addSearchLatencyP50Alarm",
        "add_search_latency_p90_alarm": "addSearchLatencyP90Alarm",
        "add_search_latency_p99_alarm": "addSearchLatencyP99Alarm",
    },
)
class OpenSearchClusterMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cluster_automated_snapshot_failure_alarm: 
        :param add_cluster_index_writes_blocked_alarm: 
        :param add_cluster_node_count_alarm: 
        :param add_cluster_status_alarm: 
        :param add_cpu_space_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_indexing_latency_p50_alarm: 
        :param add_indexing_latency_p90_alarm: 
        :param add_indexing_latency_p99_alarm: 
        :param add_jvm_memory_pressure_alarm: 
        :param add_kms_key_error_alarm: 
        :param add_kms_key_inaccessible_alarm: 
        :param add_master_cpu_space_usage_alarm: 
        :param add_master_jvm_memory_pressure_alarm: 
        :param add_search_latency_p50_alarm: 
        :param add_search_latency_p90_alarm: 
        :param add_search_latency_p99_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96d32def4059f964413575b74ba39d3a2bf2cc63d93b851be5556e6a45ca2361)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cluster_automated_snapshot_failure_alarm", value=add_cluster_automated_snapshot_failure_alarm, expected_type=type_hints["add_cluster_automated_snapshot_failure_alarm"])
            check_type(argname="argument add_cluster_index_writes_blocked_alarm", value=add_cluster_index_writes_blocked_alarm, expected_type=type_hints["add_cluster_index_writes_blocked_alarm"])
            check_type(argname="argument add_cluster_node_count_alarm", value=add_cluster_node_count_alarm, expected_type=type_hints["add_cluster_node_count_alarm"])
            check_type(argname="argument add_cluster_status_alarm", value=add_cluster_status_alarm, expected_type=type_hints["add_cluster_status_alarm"])
            check_type(argname="argument add_cpu_space_usage_alarm", value=add_cpu_space_usage_alarm, expected_type=type_hints["add_cpu_space_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_indexing_latency_p50_alarm", value=add_indexing_latency_p50_alarm, expected_type=type_hints["add_indexing_latency_p50_alarm"])
            check_type(argname="argument add_indexing_latency_p90_alarm", value=add_indexing_latency_p90_alarm, expected_type=type_hints["add_indexing_latency_p90_alarm"])
            check_type(argname="argument add_indexing_latency_p99_alarm", value=add_indexing_latency_p99_alarm, expected_type=type_hints["add_indexing_latency_p99_alarm"])
            check_type(argname="argument add_jvm_memory_pressure_alarm", value=add_jvm_memory_pressure_alarm, expected_type=type_hints["add_jvm_memory_pressure_alarm"])
            check_type(argname="argument add_kms_key_error_alarm", value=add_kms_key_error_alarm, expected_type=type_hints["add_kms_key_error_alarm"])
            check_type(argname="argument add_kms_key_inaccessible_alarm", value=add_kms_key_inaccessible_alarm, expected_type=type_hints["add_kms_key_inaccessible_alarm"])
            check_type(argname="argument add_master_cpu_space_usage_alarm", value=add_master_cpu_space_usage_alarm, expected_type=type_hints["add_master_cpu_space_usage_alarm"])
            check_type(argname="argument add_master_jvm_memory_pressure_alarm", value=add_master_jvm_memory_pressure_alarm, expected_type=type_hints["add_master_jvm_memory_pressure_alarm"])
            check_type(argname="argument add_search_latency_p50_alarm", value=add_search_latency_p50_alarm, expected_type=type_hints["add_search_latency_p50_alarm"])
            check_type(argname="argument add_search_latency_p90_alarm", value=add_search_latency_p90_alarm, expected_type=type_hints["add_search_latency_p90_alarm"])
            check_type(argname="argument add_search_latency_p99_alarm", value=add_search_latency_p99_alarm, expected_type=type_hints["add_search_latency_p99_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cluster_automated_snapshot_failure_alarm is not None:
            self._values["add_cluster_automated_snapshot_failure_alarm"] = add_cluster_automated_snapshot_failure_alarm
        if add_cluster_index_writes_blocked_alarm is not None:
            self._values["add_cluster_index_writes_blocked_alarm"] = add_cluster_index_writes_blocked_alarm
        if add_cluster_node_count_alarm is not None:
            self._values["add_cluster_node_count_alarm"] = add_cluster_node_count_alarm
        if add_cluster_status_alarm is not None:
            self._values["add_cluster_status_alarm"] = add_cluster_status_alarm
        if add_cpu_space_usage_alarm is not None:
            self._values["add_cpu_space_usage_alarm"] = add_cpu_space_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_indexing_latency_p50_alarm is not None:
            self._values["add_indexing_latency_p50_alarm"] = add_indexing_latency_p50_alarm
        if add_indexing_latency_p90_alarm is not None:
            self._values["add_indexing_latency_p90_alarm"] = add_indexing_latency_p90_alarm
        if add_indexing_latency_p99_alarm is not None:
            self._values["add_indexing_latency_p99_alarm"] = add_indexing_latency_p99_alarm
        if add_jvm_memory_pressure_alarm is not None:
            self._values["add_jvm_memory_pressure_alarm"] = add_jvm_memory_pressure_alarm
        if add_kms_key_error_alarm is not None:
            self._values["add_kms_key_error_alarm"] = add_kms_key_error_alarm
        if add_kms_key_inaccessible_alarm is not None:
            self._values["add_kms_key_inaccessible_alarm"] = add_kms_key_inaccessible_alarm
        if add_master_cpu_space_usage_alarm is not None:
            self._values["add_master_cpu_space_usage_alarm"] = add_master_cpu_space_usage_alarm
        if add_master_jvm_memory_pressure_alarm is not None:
            self._values["add_master_jvm_memory_pressure_alarm"] = add_master_jvm_memory_pressure_alarm
        if add_search_latency_p50_alarm is not None:
            self._values["add_search_latency_p50_alarm"] = add_search_latency_p50_alarm
        if add_search_latency_p90_alarm is not None:
            self._values["add_search_latency_p90_alarm"] = add_search_latency_p90_alarm
        if add_search_latency_p99_alarm is not None:
            self._values["add_search_latency_p99_alarm"] = add_search_latency_p99_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cluster_automated_snapshot_failure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterAutomatedSnapshotFailureThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_automated_snapshot_failure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterAutomatedSnapshotFailureThreshold]], result)

    @builtins.property
    def add_cluster_index_writes_blocked_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterIndexWritesBlockedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_index_writes_blocked_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterIndexWritesBlockedThreshold]], result)

    @builtins.property
    def add_cluster_node_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterNodesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_node_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterNodesThreshold]], result)

    @builtins.property
    def add_cluster_status_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterStatusCustomization]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_status_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterStatusCustomization]], result)

    @builtins.property
    def add_cpu_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_indexing_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_indexing_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_indexing_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_jvm_memory_pressure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_jvm_memory_pressure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_kms_key_error_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyErrorThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_kms_key_error_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyErrorThreshold]], result)

    @builtins.property
    def add_kms_key_inaccessible_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyInaccessibleThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_kms_key_inaccessible_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyInaccessibleThreshold]], result)

    @builtins.property
    def add_master_cpu_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_master_cpu_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_master_jvm_memory_pressure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_master_jvm_memory_pressure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_search_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_search_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_search_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.OpenSearchClusterMonitoringProps",
    jsii_struct_bases=[
        OpenSearchClusterMetricFactoryProps, OpenSearchClusterMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "domain": "domain",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cluster_automated_snapshot_failure_alarm": "addClusterAutomatedSnapshotFailureAlarm",
        "add_cluster_index_writes_blocked_alarm": "addClusterIndexWritesBlockedAlarm",
        "add_cluster_node_count_alarm": "addClusterNodeCountAlarm",
        "add_cluster_status_alarm": "addClusterStatusAlarm",
        "add_cpu_space_usage_alarm": "addCpuSpaceUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_indexing_latency_p50_alarm": "addIndexingLatencyP50Alarm",
        "add_indexing_latency_p90_alarm": "addIndexingLatencyP90Alarm",
        "add_indexing_latency_p99_alarm": "addIndexingLatencyP99Alarm",
        "add_jvm_memory_pressure_alarm": "addJvmMemoryPressureAlarm",
        "add_kms_key_error_alarm": "addKmsKeyErrorAlarm",
        "add_kms_key_inaccessible_alarm": "addKmsKeyInaccessibleAlarm",
        "add_master_cpu_space_usage_alarm": "addMasterCpuSpaceUsageAlarm",
        "add_master_jvm_memory_pressure_alarm": "addMasterJvmMemoryPressureAlarm",
        "add_search_latency_p50_alarm": "addSearchLatencyP50Alarm",
        "add_search_latency_p90_alarm": "addSearchLatencyP90Alarm",
        "add_search_latency_p99_alarm": "addSearchLatencyP99Alarm",
    },
)
class OpenSearchClusterMonitoringProps(
    OpenSearchClusterMetricFactoryProps,
    OpenSearchClusterMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param domain: 
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cluster_automated_snapshot_failure_alarm: 
        :param add_cluster_index_writes_blocked_alarm: 
        :param add_cluster_node_count_alarm: 
        :param add_cluster_status_alarm: 
        :param add_cpu_space_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_indexing_latency_p50_alarm: 
        :param add_indexing_latency_p90_alarm: 
        :param add_indexing_latency_p99_alarm: 
        :param add_jvm_memory_pressure_alarm: 
        :param add_kms_key_error_alarm: 
        :param add_kms_key_inaccessible_alarm: 
        :param add_master_cpu_space_usage_alarm: 
        :param add_master_jvm_memory_pressure_alarm: 
        :param add_search_latency_p50_alarm: 
        :param add_search_latency_p90_alarm: 
        :param add_search_latency_p99_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3f8d22987fd34d2cd522c8bcd60018be8c0a2a0e34cf6890c727b637572246e)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cluster_automated_snapshot_failure_alarm", value=add_cluster_automated_snapshot_failure_alarm, expected_type=type_hints["add_cluster_automated_snapshot_failure_alarm"])
            check_type(argname="argument add_cluster_index_writes_blocked_alarm", value=add_cluster_index_writes_blocked_alarm, expected_type=type_hints["add_cluster_index_writes_blocked_alarm"])
            check_type(argname="argument add_cluster_node_count_alarm", value=add_cluster_node_count_alarm, expected_type=type_hints["add_cluster_node_count_alarm"])
            check_type(argname="argument add_cluster_status_alarm", value=add_cluster_status_alarm, expected_type=type_hints["add_cluster_status_alarm"])
            check_type(argname="argument add_cpu_space_usage_alarm", value=add_cpu_space_usage_alarm, expected_type=type_hints["add_cpu_space_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_indexing_latency_p50_alarm", value=add_indexing_latency_p50_alarm, expected_type=type_hints["add_indexing_latency_p50_alarm"])
            check_type(argname="argument add_indexing_latency_p90_alarm", value=add_indexing_latency_p90_alarm, expected_type=type_hints["add_indexing_latency_p90_alarm"])
            check_type(argname="argument add_indexing_latency_p99_alarm", value=add_indexing_latency_p99_alarm, expected_type=type_hints["add_indexing_latency_p99_alarm"])
            check_type(argname="argument add_jvm_memory_pressure_alarm", value=add_jvm_memory_pressure_alarm, expected_type=type_hints["add_jvm_memory_pressure_alarm"])
            check_type(argname="argument add_kms_key_error_alarm", value=add_kms_key_error_alarm, expected_type=type_hints["add_kms_key_error_alarm"])
            check_type(argname="argument add_kms_key_inaccessible_alarm", value=add_kms_key_inaccessible_alarm, expected_type=type_hints["add_kms_key_inaccessible_alarm"])
            check_type(argname="argument add_master_cpu_space_usage_alarm", value=add_master_cpu_space_usage_alarm, expected_type=type_hints["add_master_cpu_space_usage_alarm"])
            check_type(argname="argument add_master_jvm_memory_pressure_alarm", value=add_master_jvm_memory_pressure_alarm, expected_type=type_hints["add_master_jvm_memory_pressure_alarm"])
            check_type(argname="argument add_search_latency_p50_alarm", value=add_search_latency_p50_alarm, expected_type=type_hints["add_search_latency_p50_alarm"])
            check_type(argname="argument add_search_latency_p90_alarm", value=add_search_latency_p90_alarm, expected_type=type_hints["add_search_latency_p90_alarm"])
            check_type(argname="argument add_search_latency_p99_alarm", value=add_search_latency_p99_alarm, expected_type=type_hints["add_search_latency_p99_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "domain": domain,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cluster_automated_snapshot_failure_alarm is not None:
            self._values["add_cluster_automated_snapshot_failure_alarm"] = add_cluster_automated_snapshot_failure_alarm
        if add_cluster_index_writes_blocked_alarm is not None:
            self._values["add_cluster_index_writes_blocked_alarm"] = add_cluster_index_writes_blocked_alarm
        if add_cluster_node_count_alarm is not None:
            self._values["add_cluster_node_count_alarm"] = add_cluster_node_count_alarm
        if add_cluster_status_alarm is not None:
            self._values["add_cluster_status_alarm"] = add_cluster_status_alarm
        if add_cpu_space_usage_alarm is not None:
            self._values["add_cpu_space_usage_alarm"] = add_cpu_space_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_indexing_latency_p50_alarm is not None:
            self._values["add_indexing_latency_p50_alarm"] = add_indexing_latency_p50_alarm
        if add_indexing_latency_p90_alarm is not None:
            self._values["add_indexing_latency_p90_alarm"] = add_indexing_latency_p90_alarm
        if add_indexing_latency_p99_alarm is not None:
            self._values["add_indexing_latency_p99_alarm"] = add_indexing_latency_p99_alarm
        if add_jvm_memory_pressure_alarm is not None:
            self._values["add_jvm_memory_pressure_alarm"] = add_jvm_memory_pressure_alarm
        if add_kms_key_error_alarm is not None:
            self._values["add_kms_key_error_alarm"] = add_kms_key_error_alarm
        if add_kms_key_inaccessible_alarm is not None:
            self._values["add_kms_key_inaccessible_alarm"] = add_kms_key_inaccessible_alarm
        if add_master_cpu_space_usage_alarm is not None:
            self._values["add_master_cpu_space_usage_alarm"] = add_master_cpu_space_usage_alarm
        if add_master_jvm_memory_pressure_alarm is not None:
            self._values["add_master_jvm_memory_pressure_alarm"] = add_master_jvm_memory_pressure_alarm
        if add_search_latency_p50_alarm is not None:
            self._values["add_search_latency_p50_alarm"] = add_search_latency_p50_alarm
        if add_search_latency_p90_alarm is not None:
            self._values["add_search_latency_p90_alarm"] = add_search_latency_p90_alarm
        if add_search_latency_p99_alarm is not None:
            self._values["add_search_latency_p99_alarm"] = add_search_latency_p99_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def domain(
        self,
    ) -> typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain]:
        '''
        :stability: experimental
        '''
        result = self._values.get("domain")
        assert result is not None, "Required property 'domain' is missing"
        return typing.cast(typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cluster_automated_snapshot_failure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterAutomatedSnapshotFailureThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_automated_snapshot_failure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterAutomatedSnapshotFailureThreshold]], result)

    @builtins.property
    def add_cluster_index_writes_blocked_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterIndexWritesBlockedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_index_writes_blocked_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterIndexWritesBlockedThreshold]], result)

    @builtins.property
    def add_cluster_node_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterNodesThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_node_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterNodesThreshold]], result)

    @builtins.property
    def add_cluster_status_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterStatusCustomization]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cluster_status_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchClusterStatusCustomization]], result)

    @builtins.property
    def add_cpu_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_indexing_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_indexing_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_indexing_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_indexing_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_jvm_memory_pressure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_jvm_memory_pressure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_kms_key_error_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyErrorThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_kms_key_error_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyErrorThreshold]], result)

    @builtins.property
    def add_kms_key_inaccessible_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyInaccessibleThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_kms_key_inaccessible_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, OpenSearchKmsKeyInaccessibleThreshold]], result)

    @builtins.property
    def add_master_cpu_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_master_cpu_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_master_jvm_memory_pressure_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_master_jvm_memory_pressure_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_search_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_search_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_search_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_search_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "OpenSearchClusterMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.QueueProcessingEc2ServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "ec2_service": "ec2Service",
        "add_dead_letter_queue_alarms": "addDeadLetterQueueAlarms",
        "add_queue_alarms": "addQueueAlarms",
        "add_service_alarms": "addServiceAlarms",
    },
)
class QueueProcessingEc2ServiceMonitoringProps(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        ec2_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingEc2Service,
        add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param ec2_service: 
        :param add_dead_letter_queue_alarms: 
        :param add_queue_alarms: 
        :param add_service_alarms: 

        :stability: experimental
        '''
        if isinstance(add_dead_letter_queue_alarms, dict):
            add_dead_letter_queue_alarms = BaseDlqAlarms(**add_dead_letter_queue_alarms)
        if isinstance(add_queue_alarms, dict):
            add_queue_alarms = BaseSqsQueueAlarms(**add_queue_alarms)
        if isinstance(add_service_alarms, dict):
            add_service_alarms = BaseFargateServiceAlarms(**add_service_alarms)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cff7fc9d3ad129c8a8dc3a541cdcba76d4ef482dcb8ea3d9a1711ae3f55d4931)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
            check_type(argname="argument add_dead_letter_queue_alarms", value=add_dead_letter_queue_alarms, expected_type=type_hints["add_dead_letter_queue_alarms"])
            check_type(argname="argument add_queue_alarms", value=add_queue_alarms, expected_type=type_hints["add_queue_alarms"])
            check_type(argname="argument add_service_alarms", value=add_service_alarms, expected_type=type_hints["add_service_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ec2_service": ec2_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_dead_letter_queue_alarms is not None:
            self._values["add_dead_letter_queue_alarms"] = add_dead_letter_queue_alarms
        if add_queue_alarms is not None:
            self._values["add_queue_alarms"] = add_queue_alarms
        if add_service_alarms is not None:
            self._values["add_service_alarms"] = add_service_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def ec2_service(
        self,
    ) -> _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingEc2Service:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingEc2Service, result)

    @builtins.property
    def add_dead_letter_queue_alarms(self) -> typing.Optional[BaseDlqAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_alarms")
        return typing.cast(typing.Optional[BaseDlqAlarms], result)

    @builtins.property
    def add_queue_alarms(self) -> typing.Optional[BaseSqsQueueAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_alarms")
        return typing.cast(typing.Optional[BaseSqsQueueAlarms], result)

    @builtins.property
    def add_service_alarms(self) -> typing.Optional[BaseFargateServiceAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_service_alarms")
        return typing.cast(typing.Optional[BaseFargateServiceAlarms], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "QueueProcessingEc2ServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.QueueProcessingFargateServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "fargate_service": "fargateService",
        "add_dead_letter_queue_alarms": "addDeadLetterQueueAlarms",
        "add_queue_alarms": "addQueueAlarms",
        "add_service_alarms": "addServiceAlarms",
    },
)
class QueueProcessingFargateServiceMonitoringProps(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        fargate_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingFargateService,
        add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
        add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param fargate_service: 
        :param add_dead_letter_queue_alarms: 
        :param add_queue_alarms: 
        :param add_service_alarms: 

        :stability: experimental
        '''
        if isinstance(add_dead_letter_queue_alarms, dict):
            add_dead_letter_queue_alarms = BaseDlqAlarms(**add_dead_letter_queue_alarms)
        if isinstance(add_queue_alarms, dict):
            add_queue_alarms = BaseSqsQueueAlarms(**add_queue_alarms)
        if isinstance(add_service_alarms, dict):
            add_service_alarms = BaseFargateServiceAlarms(**add_service_alarms)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39b9e2267d88e909794e18a10ba0f037ab69e18de50cdac527deb94a1e4e0221)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
            check_type(argname="argument add_dead_letter_queue_alarms", value=add_dead_letter_queue_alarms, expected_type=type_hints["add_dead_letter_queue_alarms"])
            check_type(argname="argument add_queue_alarms", value=add_queue_alarms, expected_type=type_hints["add_queue_alarms"])
            check_type(argname="argument add_service_alarms", value=add_service_alarms, expected_type=type_hints["add_service_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "fargate_service": fargate_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_dead_letter_queue_alarms is not None:
            self._values["add_dead_letter_queue_alarms"] = add_dead_letter_queue_alarms
        if add_queue_alarms is not None:
            self._values["add_queue_alarms"] = add_queue_alarms
        if add_service_alarms is not None:
            self._values["add_service_alarms"] = add_service_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def fargate_service(
        self,
    ) -> _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingFargateService:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingFargateService, result)

    @builtins.property
    def add_dead_letter_queue_alarms(self) -> typing.Optional[BaseDlqAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_alarms")
        return typing.cast(typing.Optional[BaseDlqAlarms], result)

    @builtins.property
    def add_queue_alarms(self) -> typing.Optional[BaseSqsQueueAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_alarms")
        return typing.cast(typing.Optional[BaseSqsQueueAlarms], result)

    @builtins.property
    def add_service_alarms(self) -> typing.Optional[BaseFargateServiceAlarms]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_service_alarms")
        return typing.cast(typing.Optional[BaseFargateServiceAlarms], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "QueueProcessingFargateServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsClusterMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RdsClusterMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e219c2939f4b9b6d12088714c4d6618b65addcf00c74c7474bd0320f659eab67)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsClusterMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsClusterMonitoringProps",
    jsii_struct_bases=[RdsClusterMetricFactoryProps, RdsClusterMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster": "cluster",
        "cluster_identifier": "clusterIdentifier",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RdsClusterMonitoringProps(
    RdsClusterMetricFactoryProps,
    RdsClusterMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cccf5c38b2eadfac7dfb25a9f9e763e0a6dbd136dd23e273f352f9df9f2cfc3)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
            check_type(argname="argument cluster_identifier", value=cluster_identifier, expected_type=type_hints["cluster_identifier"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if cluster is not None:
            self._values["cluster"] = cluster
        if cluster_identifier is not None:
            self._values["cluster_identifier"] = cluster_identifier
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]]:
        '''(experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).

        :stability: experimental
        '''
        result = self._values.get("cluster")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]], result)

    @builtins.property
    def cluster_identifier(self) -> typing.Optional[builtins.str]:
        '''(deprecated) database cluster identifier (either this or ``cluster`` need to be specified).

        :deprecated: please use ``cluster`` instead

        :stability: deprecated
        '''
        result = self._values.get("cluster_identifier")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsClusterMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsInstanceMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_free_storage_space_alarm": "addFreeStorageSpaceAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RdsInstanceMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_free_storage_space_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9931a59fbfdc40f354ea561bd032703020d39066bc7c032a80b860e46659db92)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_free_storage_space_alarm", value=add_free_storage_space_alarm, expected_type=type_hints["add_free_storage_space_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_free_storage_space_alarm is not None:
            self._values["add_free_storage_space_alarm"] = add_free_storage_space_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_free_storage_space_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_free_storage_space_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsInstanceMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RdsInstanceMonitoringProps",
    jsii_struct_bases=[RdsInstanceMetricFactoryProps, RdsInstanceMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "instance": "instance",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_free_storage_space_alarm": "addFreeStorageSpaceAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RdsInstanceMonitoringProps(
    RdsInstanceMetricFactoryProps,
    RdsInstanceMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param instance: (experimental) database instance.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_free_storage_space_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d258bbb1dfc8c915aa75a280eee01ef2e44aea4dc3b991acb4e66bf36719b46)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_free_storage_space_alarm", value=add_free_storage_space_alarm, expected_type=type_hints["add_free_storage_space_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance": instance,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_free_storage_space_alarm is not None:
            self._values["add_free_storage_space_alarm"] = add_free_storage_space_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance(self) -> _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance:
        '''(experimental) database instance.

        :stability: experimental
        '''
        result = self._values.get("instance")
        assert result is not None, "Required property 'instance' is missing"
        return typing.cast(_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_free_storage_space_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_free_storage_space_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinUsageCountThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RdsInstanceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RedshiftClusterMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_max_long_query_duration_alarm": "addMaxLongQueryDurationAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RedshiftClusterMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_long_query_duration_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__279f1230ddb7426695ad13c3a830b8eb66e046d1c02065a7d23833dfb6e37bda)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_max_long_query_duration_alarm", value=add_max_long_query_duration_alarm, expected_type=type_hints["add_max_long_query_duration_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_max_long_query_duration_alarm is not None:
            self._values["add_max_long_query_duration_alarm"] = add_max_long_query_duration_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_max_long_query_duration_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_long_query_duration_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RedshiftClusterMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.RedshiftClusterMonitoringProps",
    jsii_struct_bases=[
        RedshiftClusterMetricFactoryProps, RedshiftClusterMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster_identifier": "clusterIdentifier",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_disk_space_usage_alarm": "addDiskSpaceUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_max_long_query_duration_alarm": "addMaxLongQueryDurationAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class RedshiftClusterMonitoringProps(
    RedshiftClusterMetricFactoryProps,
    RedshiftClusterMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster_identifier: builtins.str,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster_identifier: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_disk_space_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_long_query_duration_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__318ed0bcb384be05f1813e20ee6b99241c45d6d23eaaeef5a6689c52e3ec83c8)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster_identifier", value=cluster_identifier, expected_type=type_hints["cluster_identifier"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_disk_space_usage_alarm", value=add_disk_space_usage_alarm, expected_type=type_hints["add_disk_space_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_max_long_query_duration_alarm", value=add_max_long_query_duration_alarm, expected_type=type_hints["add_max_long_query_duration_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cluster_identifier": cluster_identifier,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_disk_space_usage_alarm is not None:
            self._values["add_disk_space_usage_alarm"] = add_disk_space_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_max_long_query_duration_alarm is not None:
            self._values["add_max_long_query_duration_alarm"] = add_max_long_query_duration_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster_identifier(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("cluster_identifier")
        assert result is not None, "Required property 'cluster_identifier' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_disk_space_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_disk_space_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_max_long_query_duration_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_long_query_duration_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RedshiftClusterMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.S3BucketMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class S3BucketMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86d9fb9242f927f6636bcb9208a2ee375457e90989fdeefcd6bf10acff3afd47)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3BucketMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.S3BucketMonitoringProps",
    jsii_struct_bases=[S3BucketMetricFactoryProps, S3BucketMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "bucket": "bucket",
        "storage_type": "storageType",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class S3BucketMonitoringProps(S3BucketMetricFactoryProps, S3BucketMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        storage_type: typing.Optional[StorageType] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param bucket: 
        :param storage_type: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a70b8e7362ba6c269e6eb3977b2ef9cc979176362788ee51c28c075080bbc36)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if storage_type is not None:
            self._values["storage_type"] = storage_type
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
        '''
        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, result)

    @builtins.property
    def storage_type(self) -> typing.Optional[StorageType]:
        '''
        :stability: experimental
        '''
        result = self._values.get("storage_type")
        return typing.cast(typing.Optional[StorageType], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3BucketMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SecretsManagerMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_change_in_secrets_alarm": "addChangeInSecretsAlarm",
        "add_max_number_secrets_alarm": "addMaxNumberSecretsAlarm",
        "add_min_number_secrets_alarm": "addMinNumberSecretsAlarm",
    },
)
class SecretsManagerMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_change_in_secrets_alarm: 
        :param add_max_number_secrets_alarm: 
        :param add_min_number_secrets_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae801214ce0813ff9ab3a1bd501bd7b46ceca77529881780d95cd7bc4624fd43)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_change_in_secrets_alarm", value=add_change_in_secrets_alarm, expected_type=type_hints["add_change_in_secrets_alarm"])
            check_type(argname="argument add_max_number_secrets_alarm", value=add_max_number_secrets_alarm, expected_type=type_hints["add_max_number_secrets_alarm"])
            check_type(argname="argument add_min_number_secrets_alarm", value=add_min_number_secrets_alarm, expected_type=type_hints["add_min_number_secrets_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_change_in_secrets_alarm is not None:
            self._values["add_change_in_secrets_alarm"] = add_change_in_secrets_alarm
        if add_max_number_secrets_alarm is not None:
            self._values["add_max_number_secrets_alarm"] = add_max_number_secrets_alarm
        if add_min_number_secrets_alarm is not None:
            self._values["add_min_number_secrets_alarm"] = add_min_number_secrets_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_change_in_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ChangeInSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_change_in_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ChangeInSecretCountThreshold]], result)

    @builtins.property
    def add_max_number_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_number_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxSecretCountThreshold]], result)

    @builtins.property
    def add_min_number_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_number_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinSecretCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecretsManagerMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SecretsManagerMonitoringProps",
    jsii_struct_bases=[SecretsManagerMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_change_in_secrets_alarm": "addChangeInSecretsAlarm",
        "add_max_number_secrets_alarm": "addMaxNumberSecretsAlarm",
        "add_min_number_secrets_alarm": "addMinNumberSecretsAlarm",
    },
)
class SecretsManagerMonitoringProps(SecretsManagerMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_change_in_secrets_alarm: 
        :param add_max_number_secrets_alarm: 
        :param add_min_number_secrets_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bee12a48d6d7ef767b366302fa038929bfc298df919886dd7f0c40f2d81678a1)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_change_in_secrets_alarm", value=add_change_in_secrets_alarm, expected_type=type_hints["add_change_in_secrets_alarm"])
            check_type(argname="argument add_max_number_secrets_alarm", value=add_max_number_secrets_alarm, expected_type=type_hints["add_max_number_secrets_alarm"])
            check_type(argname="argument add_min_number_secrets_alarm", value=add_min_number_secrets_alarm, expected_type=type_hints["add_min_number_secrets_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_change_in_secrets_alarm is not None:
            self._values["add_change_in_secrets_alarm"] = add_change_in_secrets_alarm
        if add_max_number_secrets_alarm is not None:
            self._values["add_max_number_secrets_alarm"] = add_max_number_secrets_alarm
        if add_min_number_secrets_alarm is not None:
            self._values["add_min_number_secrets_alarm"] = add_min_number_secrets_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_change_in_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ChangeInSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_change_in_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ChangeInSecretCountThreshold]], result)

    @builtins.property
    def add_max_number_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_number_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxSecretCountThreshold]], result)

    @builtins.property
    def add_min_number_secrets_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinSecretCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_number_secrets_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinSecretCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecretsManagerMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SecretsManagerSecretMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_days_since_last_change_alarm": "addDaysSinceLastChangeAlarm",
        "add_days_since_last_rotation_alarm": "addDaysSinceLastRotationAlarm",
        "show_last_rotation_widget": "showLastRotationWidget",
        "use_publisher": "usePublisher",
    },
)
class SecretsManagerSecretMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        show_last_rotation_widget: typing.Optional[builtins.bool] = None,
        use_publisher: typing.Optional[IPublisherConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_days_since_last_change_alarm: 
        :param add_days_since_last_rotation_alarm: 
        :param show_last_rotation_widget: Default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.
        :param use_publisher: (experimental) Provides access to the underlying metrics publisher Lambda function. This may be useful if you want to monitor the function itself.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3df57dbef7f5517abf0ee4985240dab87c3280573198a138b608c6b17adca6e4)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_days_since_last_change_alarm", value=add_days_since_last_change_alarm, expected_type=type_hints["add_days_since_last_change_alarm"])
            check_type(argname="argument add_days_since_last_rotation_alarm", value=add_days_since_last_rotation_alarm, expected_type=type_hints["add_days_since_last_rotation_alarm"])
            check_type(argname="argument show_last_rotation_widget", value=show_last_rotation_widget, expected_type=type_hints["show_last_rotation_widget"])
            check_type(argname="argument use_publisher", value=use_publisher, expected_type=type_hints["use_publisher"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_days_since_last_change_alarm is not None:
            self._values["add_days_since_last_change_alarm"] = add_days_since_last_change_alarm
        if add_days_since_last_rotation_alarm is not None:
            self._values["add_days_since_last_rotation_alarm"] = add_days_since_last_rotation_alarm
        if show_last_rotation_widget is not None:
            self._values["show_last_rotation_widget"] = show_last_rotation_widget
        if use_publisher is not None:
            self._values["use_publisher"] = use_publisher

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_days_since_last_change_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_since_last_change_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]], result)

    @builtins.property
    def add_days_since_last_rotation_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_since_last_rotation_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]], result)

    @builtins.property
    def show_last_rotation_widget(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.

        :stability: experimental
        '''
        result = self._values.get("show_last_rotation_widget")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_publisher(self) -> typing.Optional[IPublisherConsumer]:
        '''(experimental) Provides access to the underlying metrics publisher Lambda function.

        This may be useful if you want to monitor the function itself.

        :stability: experimental
        '''
        result = self._values.get("use_publisher")
        return typing.cast(typing.Optional[IPublisherConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecretsManagerSecretMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SecretsManagerSecretMonitoringProps",
    jsii_struct_bases=[
        SecretsManagerSecretMetricFactoryProps, SecretsManagerSecretMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "secret": "secret",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_days_since_last_change_alarm": "addDaysSinceLastChangeAlarm",
        "add_days_since_last_rotation_alarm": "addDaysSinceLastRotationAlarm",
        "show_last_rotation_widget": "showLastRotationWidget",
        "use_publisher": "usePublisher",
    },
)
class SecretsManagerSecretMonitoringProps(
    SecretsManagerSecretMetricFactoryProps,
    SecretsManagerSecretMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        show_last_rotation_widget: typing.Optional[builtins.bool] = None,
        use_publisher: typing.Optional[IPublisherConsumer] = None,
    ) -> None:
        '''(experimental) Monitoring props for Secrets Manager secrets.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param secret: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_days_since_last_change_alarm: 
        :param add_days_since_last_rotation_alarm: 
        :param show_last_rotation_widget: Default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.
        :param use_publisher: (experimental) Provides access to the underlying metrics publisher Lambda function. This may be useful if you want to monitor the function itself.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed2f768a4e58e42beabd7414a632d6f0050cd9a8c667ea13b88f504b48eb0e8a)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument secret", value=secret, expected_type=type_hints["secret"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_days_since_last_change_alarm", value=add_days_since_last_change_alarm, expected_type=type_hints["add_days_since_last_change_alarm"])
            check_type(argname="argument add_days_since_last_rotation_alarm", value=add_days_since_last_rotation_alarm, expected_type=type_hints["add_days_since_last_rotation_alarm"])
            check_type(argname="argument show_last_rotation_widget", value=show_last_rotation_widget, expected_type=type_hints["show_last_rotation_widget"])
            check_type(argname="argument use_publisher", value=use_publisher, expected_type=type_hints["use_publisher"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "secret": secret,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_days_since_last_change_alarm is not None:
            self._values["add_days_since_last_change_alarm"] = add_days_since_last_change_alarm
        if add_days_since_last_rotation_alarm is not None:
            self._values["add_days_since_last_rotation_alarm"] = add_days_since_last_rotation_alarm
        if show_last_rotation_widget is not None:
            self._values["show_last_rotation_widget"] = show_last_rotation_widget
        if use_publisher is not None:
            self._values["use_publisher"] = use_publisher

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secret(self) -> _aws_cdk_aws_secretsmanager_ceddda9d.ISecret:
        '''
        :stability: experimental
        '''
        result = self._values.get("secret")
        assert result is not None, "Required property 'secret' is missing"
        return typing.cast(_aws_cdk_aws_secretsmanager_ceddda9d.ISecret, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_days_since_last_change_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_since_last_change_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]], result)

    @builtins.property
    def add_days_since_last_rotation_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_days_since_last_rotation_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DaysSinceUpdateThreshold]], result)

    @builtins.property
    def show_last_rotation_widget(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true, if ``addDaysSinceLastRotationAlarm`` is set, otherwise ``false``.

        :stability: experimental
        '''
        result = self._values.get("show_last_rotation_widget")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_publisher(self) -> typing.Optional[IPublisherConsumer]:
        '''(experimental) Provides access to the underlying metrics publisher Lambda function.

        This may be useful if you want to monitor the function itself.

        :stability: experimental
        '''
        result = self._values.get("use_publisher")
        return typing.cast(typing.Optional[IPublisherConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecretsManagerSecretMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SimpleEc2ServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseEc2ServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "ec2_service": "ec2Service",
    },
)
class SimpleEc2ServiceMonitoringProps(BaseMonitoringProps, BaseEc2ServiceAlarms):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
    ) -> None:
        '''(experimental) Monitoring props for Simple EC2 service.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param ec2_service: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c535902c60dd4f7811a7db698d2c53c97c0dde23a6395960a08a7070e91f836)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument ec2_service", value=ec2_service, expected_type=type_hints["ec2_service"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ec2_service": ec2_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ec2_service(self) -> _aws_cdk_aws_ecs_ceddda9d.Ec2Service:
        '''
        :stability: experimental
        '''
        result = self._values.get("ec2_service")
        assert result is not None, "Required property 'ec2_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.Ec2Service, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SimpleEc2ServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SimpleFargateServiceMonitoringProps",
    jsii_struct_bases=[BaseMonitoringProps, BaseFargateServiceAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_ephermal_storage_usage_alarm": "addEphermalStorageUsageAlarm",
        "add_memory_usage_alarm": "addMemoryUsageAlarm",
        "add_running_task_count_alarm": "addRunningTaskCountAlarm",
        "max_auto_scaling_task_count": "maxAutoScalingTaskCount",
        "min_auto_scaling_task_count": "minAutoScalingTaskCount",
        "fargate_service": "fargateService",
    },
)
class SimpleFargateServiceMonitoringProps(
    BaseMonitoringProps,
    BaseFargateServiceAlarms,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
        fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
    ) -> None:
        '''(experimental) Monitoring props for Simple Fargate service.

        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_ephermal_storage_usage_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param add_memory_usage_alarm: 
        :param add_running_task_count_alarm: (experimental) Container Insights needs to be enabled for the cluster for this alarm.
        :param max_auto_scaling_task_count: (experimental) Maximum number of tasks, as specified in your auto scaling config.
        :param min_auto_scaling_task_count: (experimental) Minimum number of tasks, as specified in your auto scaling config.
        :param fargate_service: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87470398c0479654a1b234bc837ba5ebcba77a0a9b31e1cd24f74e47199cbb33)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_ephermal_storage_usage_alarm", value=add_ephermal_storage_usage_alarm, expected_type=type_hints["add_ephermal_storage_usage_alarm"])
            check_type(argname="argument add_memory_usage_alarm", value=add_memory_usage_alarm, expected_type=type_hints["add_memory_usage_alarm"])
            check_type(argname="argument add_running_task_count_alarm", value=add_running_task_count_alarm, expected_type=type_hints["add_running_task_count_alarm"])
            check_type(argname="argument max_auto_scaling_task_count", value=max_auto_scaling_task_count, expected_type=type_hints["max_auto_scaling_task_count"])
            check_type(argname="argument min_auto_scaling_task_count", value=min_auto_scaling_task_count, expected_type=type_hints["min_auto_scaling_task_count"])
            check_type(argname="argument fargate_service", value=fargate_service, expected_type=type_hints["fargate_service"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "fargate_service": fargate_service,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_ephermal_storage_usage_alarm is not None:
            self._values["add_ephermal_storage_usage_alarm"] = add_ephermal_storage_usage_alarm
        if add_memory_usage_alarm is not None:
            self._values["add_memory_usage_alarm"] = add_memory_usage_alarm
        if add_running_task_count_alarm is not None:
            self._values["add_running_task_count_alarm"] = add_running_task_count_alarm
        if max_auto_scaling_task_count is not None:
            self._values["max_auto_scaling_task_count"] = max_auto_scaling_task_count
        if min_auto_scaling_task_count is not None:
            self._values["min_auto_scaling_task_count"] = min_auto_scaling_task_count

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_ephermal_storage_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_ephermal_storage_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_memory_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_memory_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_running_task_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]]:
        '''(experimental) Container Insights needs to be enabled for the cluster for this alarm.

        :stability: experimental
        '''
        result = self._values.get("add_running_task_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, RunningTaskCountThreshold]], result)

    @builtins.property
    def max_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("max_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_auto_scaling_task_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum number of tasks, as specified in your auto scaling config.

        :stability: experimental
        '''
        result = self._values.get("min_auto_scaling_task_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def fargate_service(self) -> _aws_cdk_aws_ecs_ceddda9d.FargateService:
        '''
        :stability: experimental
        '''
        result = self._values.get("fargate_service")
        assert result is not None, "Required property 'fargate_service' is missing"
        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.FargateService, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SimpleFargateServiceMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SnsTopicMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_max_number_of_messages_published_alarm": "addMaxNumberOfMessagesPublishedAlarm",
        "add_message_notifications_failed_alarm": "addMessageNotificationsFailedAlarm",
        "add_min_number_of_messages_published_alarm": "addMinNumberOfMessagesPublishedAlarm",
    },
)
class SnsTopicMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_max_number_of_messages_published_alarm: 
        :param add_message_notifications_failed_alarm: 
        :param add_min_number_of_messages_published_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb560a82205708572b3b74c8e3d2fba4dac6476aa342f5c5df39f3dbeb5f0b88)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_max_number_of_messages_published_alarm", value=add_max_number_of_messages_published_alarm, expected_type=type_hints["add_max_number_of_messages_published_alarm"])
            check_type(argname="argument add_message_notifications_failed_alarm", value=add_message_notifications_failed_alarm, expected_type=type_hints["add_message_notifications_failed_alarm"])
            check_type(argname="argument add_min_number_of_messages_published_alarm", value=add_min_number_of_messages_published_alarm, expected_type=type_hints["add_min_number_of_messages_published_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_max_number_of_messages_published_alarm is not None:
            self._values["add_max_number_of_messages_published_alarm"] = add_max_number_of_messages_published_alarm
        if add_message_notifications_failed_alarm is not None:
            self._values["add_message_notifications_failed_alarm"] = add_message_notifications_failed_alarm
        if add_min_number_of_messages_published_alarm is not None:
            self._values["add_min_number_of_messages_published_alarm"] = add_min_number_of_messages_published_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_max_number_of_messages_published_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighMessagesPublishedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_number_of_messages_published_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighMessagesPublishedThreshold]], result)

    @builtins.property
    def add_message_notifications_failed_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, NotificationsFailedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_message_notifications_failed_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, NotificationsFailedThreshold]], result)

    @builtins.property
    def add_min_number_of_messages_published_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowMessagesPublishedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_number_of_messages_published_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowMessagesPublishedThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SnsTopicMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SnsTopicMonitoringProps",
    jsii_struct_bases=[SnsTopicMetricFactoryProps, SnsTopicMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "topic": "topic",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_max_number_of_messages_published_alarm": "addMaxNumberOfMessagesPublishedAlarm",
        "add_message_notifications_failed_alarm": "addMessageNotificationsFailedAlarm",
        "add_min_number_of_messages_published_alarm": "addMinNumberOfMessagesPublishedAlarm",
    },
)
class SnsTopicMonitoringProps(SnsTopicMetricFactoryProps, SnsTopicMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param topic: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_max_number_of_messages_published_alarm: 
        :param add_message_notifications_failed_alarm: 
        :param add_min_number_of_messages_published_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f1112f4cb0e094faaedce0d97684d956b5bcfeefaa6b45f65ddf400c4c980f6)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_max_number_of_messages_published_alarm", value=add_max_number_of_messages_published_alarm, expected_type=type_hints["add_max_number_of_messages_published_alarm"])
            check_type(argname="argument add_message_notifications_failed_alarm", value=add_message_notifications_failed_alarm, expected_type=type_hints["add_message_notifications_failed_alarm"])
            check_type(argname="argument add_min_number_of_messages_published_alarm", value=add_min_number_of_messages_published_alarm, expected_type=type_hints["add_min_number_of_messages_published_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "topic": topic,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_max_number_of_messages_published_alarm is not None:
            self._values["add_max_number_of_messages_published_alarm"] = add_max_number_of_messages_published_alarm
        if add_message_notifications_failed_alarm is not None:
            self._values["add_message_notifications_failed_alarm"] = add_message_notifications_failed_alarm
        if add_min_number_of_messages_published_alarm is not None:
            self._values["add_min_number_of_messages_published_alarm"] = add_min_number_of_messages_published_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def topic(self) -> _aws_cdk_aws_sns_ceddda9d.ITopic:
        '''
        :stability: experimental
        '''
        result = self._values.get("topic")
        assert result is not None, "Required property 'topic' is missing"
        return typing.cast(_aws_cdk_aws_sns_ceddda9d.ITopic, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_max_number_of_messages_published_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighMessagesPublishedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_number_of_messages_published_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighMessagesPublishedThreshold]], result)

    @builtins.property
    def add_message_notifications_failed_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, NotificationsFailedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_message_notifications_failed_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, NotificationsFailedThreshold]], result)

    @builtins.property
    def add_min_number_of_messages_published_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowMessagesPublishedThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_number_of_messages_published_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowMessagesPublishedThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SnsTopicMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SqsQueueMonitoringOptions",
    jsii_struct_bases=[BaseSqsQueueAlarms, BaseMonitoringProps],
    name_mapping={
        "add_queue_max_incoming_messages_alarm": "addQueueMaxIncomingMessagesAlarm",
        "add_queue_max_message_age_alarm": "addQueueMaxMessageAgeAlarm",
        "add_queue_max_size_alarm": "addQueueMaxSizeAlarm",
        "add_queue_max_time_to_drain_messages_alarm": "addQueueMaxTimeToDrainMessagesAlarm",
        "add_queue_min_incoming_messages_alarm": "addQueueMinIncomingMessagesAlarm",
        "add_queue_min_size_alarm": "addQueueMinSizeAlarm",
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class SqsQueueMonitoringOptions(BaseSqsQueueAlarms, BaseMonitoringProps):
    def __init__(
        self,
        *,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a9078704844c2d99f4c20a13ce61629c7084ecba92e599c550938bdff60bcdd)
            check_type(argname="argument add_queue_max_incoming_messages_alarm", value=add_queue_max_incoming_messages_alarm, expected_type=type_hints["add_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_queue_max_message_age_alarm", value=add_queue_max_message_age_alarm, expected_type=type_hints["add_queue_max_message_age_alarm"])
            check_type(argname="argument add_queue_max_size_alarm", value=add_queue_max_size_alarm, expected_type=type_hints["add_queue_max_size_alarm"])
            check_type(argname="argument add_queue_max_time_to_drain_messages_alarm", value=add_queue_max_time_to_drain_messages_alarm, expected_type=type_hints["add_queue_max_time_to_drain_messages_alarm"])
            check_type(argname="argument add_queue_min_incoming_messages_alarm", value=add_queue_min_incoming_messages_alarm, expected_type=type_hints["add_queue_min_incoming_messages_alarm"])
            check_type(argname="argument add_queue_min_size_alarm", value=add_queue_min_size_alarm, expected_type=type_hints["add_queue_min_size_alarm"])
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if add_queue_max_incoming_messages_alarm is not None:
            self._values["add_queue_max_incoming_messages_alarm"] = add_queue_max_incoming_messages_alarm
        if add_queue_max_message_age_alarm is not None:
            self._values["add_queue_max_message_age_alarm"] = add_queue_max_message_age_alarm
        if add_queue_max_size_alarm is not None:
            self._values["add_queue_max_size_alarm"] = add_queue_max_size_alarm
        if add_queue_max_time_to_drain_messages_alarm is not None:
            self._values["add_queue_max_time_to_drain_messages_alarm"] = add_queue_max_time_to_drain_messages_alarm
        if add_queue_min_incoming_messages_alarm is not None:
            self._values["add_queue_min_incoming_messages_alarm"] = add_queue_min_incoming_messages_alarm
        if add_queue_min_size_alarm is not None:
            self._values["add_queue_min_size_alarm"] = add_queue_min_size_alarm
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def add_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]], result)

    @builtins.property
    def add_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]], result)

    @builtins.property
    def add_queue_max_time_to_drain_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_time_to_drain_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]], result)

    @builtins.property
    def add_queue_min_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_min_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]], result)

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SqsQueueMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SqsQueueMonitoringProps",
    jsii_struct_bases=[SqsQueueMetricFactoryProps, SqsQueueMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "queue": "queue",
        "add_queue_max_incoming_messages_alarm": "addQueueMaxIncomingMessagesAlarm",
        "add_queue_max_message_age_alarm": "addQueueMaxMessageAgeAlarm",
        "add_queue_max_size_alarm": "addQueueMaxSizeAlarm",
        "add_queue_max_time_to_drain_messages_alarm": "addQueueMaxTimeToDrainMessagesAlarm",
        "add_queue_min_incoming_messages_alarm": "addQueueMinIncomingMessagesAlarm",
        "add_queue_min_size_alarm": "addQueueMinSizeAlarm",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class SqsQueueMonitoringProps(SqsQueueMetricFactoryProps, SqsQueueMonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param queue: 
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6532398ecbbb3fa4eee48c0fc6d0857bdb4fadad7fb341a798b53258c0e97936)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument queue", value=queue, expected_type=type_hints["queue"])
            check_type(argname="argument add_queue_max_incoming_messages_alarm", value=add_queue_max_incoming_messages_alarm, expected_type=type_hints["add_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_queue_max_message_age_alarm", value=add_queue_max_message_age_alarm, expected_type=type_hints["add_queue_max_message_age_alarm"])
            check_type(argname="argument add_queue_max_size_alarm", value=add_queue_max_size_alarm, expected_type=type_hints["add_queue_max_size_alarm"])
            check_type(argname="argument add_queue_max_time_to_drain_messages_alarm", value=add_queue_max_time_to_drain_messages_alarm, expected_type=type_hints["add_queue_max_time_to_drain_messages_alarm"])
            check_type(argname="argument add_queue_min_incoming_messages_alarm", value=add_queue_min_incoming_messages_alarm, expected_type=type_hints["add_queue_min_incoming_messages_alarm"])
            check_type(argname="argument add_queue_min_size_alarm", value=add_queue_min_size_alarm, expected_type=type_hints["add_queue_min_size_alarm"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "queue": queue,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if add_queue_max_incoming_messages_alarm is not None:
            self._values["add_queue_max_incoming_messages_alarm"] = add_queue_max_incoming_messages_alarm
        if add_queue_max_message_age_alarm is not None:
            self._values["add_queue_max_message_age_alarm"] = add_queue_max_message_age_alarm
        if add_queue_max_size_alarm is not None:
            self._values["add_queue_max_size_alarm"] = add_queue_max_size_alarm
        if add_queue_max_time_to_drain_messages_alarm is not None:
            self._values["add_queue_max_time_to_drain_messages_alarm"] = add_queue_max_time_to_drain_messages_alarm
        if add_queue_min_incoming_messages_alarm is not None:
            self._values["add_queue_min_incoming_messages_alarm"] = add_queue_min_incoming_messages_alarm
        if add_queue_min_size_alarm is not None:
            self._values["add_queue_min_size_alarm"] = add_queue_min_size_alarm
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        '''
        :stability: experimental
        '''
        result = self._values.get("queue")
        assert result is not None, "Required property 'queue' is missing"
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, result)

    @builtins.property
    def add_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]], result)

    @builtins.property
    def add_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]], result)

    @builtins.property
    def add_queue_max_time_to_drain_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_time_to_drain_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]], result)

    @builtins.property
    def add_queue_min_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_min_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SqsQueueMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SqsQueueMonitoringWithDlqProps",
    jsii_struct_bases=[SqsQueueMonitoringProps, BaseDlqAlarms],
    name_mapping={
        "account": "account",
        "region": "region",
        "queue": "queue",
        "add_queue_max_incoming_messages_alarm": "addQueueMaxIncomingMessagesAlarm",
        "add_queue_max_message_age_alarm": "addQueueMaxMessageAgeAlarm",
        "add_queue_max_size_alarm": "addQueueMaxSizeAlarm",
        "add_queue_max_time_to_drain_messages_alarm": "addQueueMaxTimeToDrainMessagesAlarm",
        "add_queue_min_incoming_messages_alarm": "addQueueMinIncomingMessagesAlarm",
        "add_queue_min_size_alarm": "addQueueMinSizeAlarm",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_dead_letter_queue_max_incoming_messages_alarm": "addDeadLetterQueueMaxIncomingMessagesAlarm",
        "add_dead_letter_queue_max_message_age_alarm": "addDeadLetterQueueMaxMessageAgeAlarm",
        "add_dead_letter_queue_max_size_alarm": "addDeadLetterQueueMaxSizeAlarm",
        "dead_letter_queue": "deadLetterQueue",
        "add_dead_letter_queue_to_summary_dashboard": "addDeadLetterQueueToSummaryDashboard",
    },
)
class SqsQueueMonitoringWithDlqProps(SqsQueueMonitoringProps, BaseDlqAlarms):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        dead_letter_queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
        add_dead_letter_queue_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param queue: 
        :param add_queue_max_incoming_messages_alarm: 
        :param add_queue_max_message_age_alarm: 
        :param add_queue_max_size_alarm: 
        :param add_queue_max_time_to_drain_messages_alarm: 
        :param add_queue_min_incoming_messages_alarm: 
        :param add_queue_min_size_alarm: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_dead_letter_queue_max_incoming_messages_alarm: (experimental) Alarm on the number of messages added to a queue. Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ as a result of a failed processing attempt.
        :param add_dead_letter_queue_max_message_age_alarm: 
        :param add_dead_letter_queue_max_size_alarm: 
        :param dead_letter_queue: 
        :param add_dead_letter_queue_to_summary_dashboard: (experimental) Indicates whether the DLQ monitoring should be added to summary dashboard. Default: - true

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0b15e4a0097bb5021a86236dfc10fb0f7d61edb4838c9bed5159404006dde085)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument queue", value=queue, expected_type=type_hints["queue"])
            check_type(argname="argument add_queue_max_incoming_messages_alarm", value=add_queue_max_incoming_messages_alarm, expected_type=type_hints["add_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_queue_max_message_age_alarm", value=add_queue_max_message_age_alarm, expected_type=type_hints["add_queue_max_message_age_alarm"])
            check_type(argname="argument add_queue_max_size_alarm", value=add_queue_max_size_alarm, expected_type=type_hints["add_queue_max_size_alarm"])
            check_type(argname="argument add_queue_max_time_to_drain_messages_alarm", value=add_queue_max_time_to_drain_messages_alarm, expected_type=type_hints["add_queue_max_time_to_drain_messages_alarm"])
            check_type(argname="argument add_queue_min_incoming_messages_alarm", value=add_queue_min_incoming_messages_alarm, expected_type=type_hints["add_queue_min_incoming_messages_alarm"])
            check_type(argname="argument add_queue_min_size_alarm", value=add_queue_min_size_alarm, expected_type=type_hints["add_queue_min_size_alarm"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_dead_letter_queue_max_incoming_messages_alarm", value=add_dead_letter_queue_max_incoming_messages_alarm, expected_type=type_hints["add_dead_letter_queue_max_incoming_messages_alarm"])
            check_type(argname="argument add_dead_letter_queue_max_message_age_alarm", value=add_dead_letter_queue_max_message_age_alarm, expected_type=type_hints["add_dead_letter_queue_max_message_age_alarm"])
            check_type(argname="argument add_dead_letter_queue_max_size_alarm", value=add_dead_letter_queue_max_size_alarm, expected_type=type_hints["add_dead_letter_queue_max_size_alarm"])
            check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
            check_type(argname="argument add_dead_letter_queue_to_summary_dashboard", value=add_dead_letter_queue_to_summary_dashboard, expected_type=type_hints["add_dead_letter_queue_to_summary_dashboard"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "queue": queue,
            "dead_letter_queue": dead_letter_queue,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if add_queue_max_incoming_messages_alarm is not None:
            self._values["add_queue_max_incoming_messages_alarm"] = add_queue_max_incoming_messages_alarm
        if add_queue_max_message_age_alarm is not None:
            self._values["add_queue_max_message_age_alarm"] = add_queue_max_message_age_alarm
        if add_queue_max_size_alarm is not None:
            self._values["add_queue_max_size_alarm"] = add_queue_max_size_alarm
        if add_queue_max_time_to_drain_messages_alarm is not None:
            self._values["add_queue_max_time_to_drain_messages_alarm"] = add_queue_max_time_to_drain_messages_alarm
        if add_queue_min_incoming_messages_alarm is not None:
            self._values["add_queue_min_incoming_messages_alarm"] = add_queue_min_incoming_messages_alarm
        if add_queue_min_size_alarm is not None:
            self._values["add_queue_min_size_alarm"] = add_queue_min_size_alarm
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_dead_letter_queue_max_incoming_messages_alarm is not None:
            self._values["add_dead_letter_queue_max_incoming_messages_alarm"] = add_dead_letter_queue_max_incoming_messages_alarm
        if add_dead_letter_queue_max_message_age_alarm is not None:
            self._values["add_dead_letter_queue_max_message_age_alarm"] = add_dead_letter_queue_max_message_age_alarm
        if add_dead_letter_queue_max_size_alarm is not None:
            self._values["add_dead_letter_queue_max_size_alarm"] = add_dead_letter_queue_max_size_alarm
        if add_dead_letter_queue_to_summary_dashboard is not None:
            self._values["add_dead_letter_queue_to_summary_dashboard"] = add_dead_letter_queue_to_summary_dashboard

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        '''
        :stability: experimental
        '''
        result = self._values.get("queue")
        assert result is not None, "Required property 'queue' is missing"
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, result)

    @builtins.property
    def add_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]], result)

    @builtins.property
    def add_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]], result)

    @builtins.property
    def add_queue_max_time_to_drain_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_max_time_to_drain_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxTimeToDrainThreshold]], result)

    @builtins.property
    def add_queue_min_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_queue_min_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_queue_min_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinMessageCountThreshold]], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_dead_letter_queue_max_incoming_messages_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]]:
        '''(experimental) Alarm on the number of messages added to a queue.

        Note that this corresponds with the NumberOfMessagesSent metric, which does not capture messages sent to the DLQ
        as a result of a failed processing attempt.

        :see: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html#sqs-dlq-number-of-messages
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_incoming_messages_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxIncomingMessagesCountThreshold]], result)

    @builtins.property
    def add_dead_letter_queue_max_message_age_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_message_age_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageAgeThreshold]], result)

    @builtins.property
    def add_dead_letter_queue_max_size_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_max_size_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MaxMessageCountThreshold]], result)

    @builtins.property
    def dead_letter_queue(self) -> _aws_cdk_aws_sqs_ceddda9d.IQueue:
        '''
        :stability: experimental
        '''
        result = self._values.get("dead_letter_queue")
        assert result is not None, "Required property 'dead_letter_queue' is missing"
        return typing.cast(_aws_cdk_aws_sqs_ceddda9d.IQueue, result)

    @builtins.property
    def add_dead_letter_queue_to_summary_dashboard(
        self,
    ) -> typing.Optional[builtins.bool]:
        '''(experimental) Indicates whether the DLQ monitoring should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_dead_letter_queue_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SqsQueueMonitoringWithDlqProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionActivityMonitoringProps",
    jsii_struct_bases=[StepFunctionActivityMetricFactoryProps, BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "activity": "activity",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_activities_count_alarm": "addFailedActivitiesCountAlarm",
        "add_failed_activities_rate_alarm": "addFailedActivitiesRateAlarm",
        "add_timed_out_activities_count_alarm": "addTimedOutActivitiesCountAlarm",
    },
)
class StepFunctionActivityMonitoringProps(
    StepFunctionActivityMetricFactoryProps,
    BaseMonitoringProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_activities_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param activity: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_activities_count_alarm: 
        :param add_failed_activities_rate_alarm: 
        :param add_timed_out_activities_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3219deac3e59d18dbb16d784c4e03451e55723c7693dc908e0d221c53e1c5d32)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument activity", value=activity, expected_type=type_hints["activity"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_activities_count_alarm", value=add_failed_activities_count_alarm, expected_type=type_hints["add_failed_activities_count_alarm"])
            check_type(argname="argument add_failed_activities_rate_alarm", value=add_failed_activities_rate_alarm, expected_type=type_hints["add_failed_activities_rate_alarm"])
            check_type(argname="argument add_timed_out_activities_count_alarm", value=add_timed_out_activities_count_alarm, expected_type=type_hints["add_timed_out_activities_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "activity": activity,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_activities_count_alarm is not None:
            self._values["add_failed_activities_count_alarm"] = add_failed_activities_count_alarm
        if add_failed_activities_rate_alarm is not None:
            self._values["add_failed_activities_rate_alarm"] = add_failed_activities_rate_alarm
        if add_timed_out_activities_count_alarm is not None:
            self._values["add_timed_out_activities_count_alarm"] = add_timed_out_activities_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def activity(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.IActivity:
        '''
        :stability: experimental
        '''
        result = self._values.get("activity")
        assert result is not None, "Required property 'activity' is missing"
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.IActivity, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_activities_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_activities_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_activities_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_activities_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_timed_out_activities_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_timed_out_activities_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionActivityMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionLambdaIntegrationMonitoringProps",
    jsii_struct_bases=[
        StepFunctionLambdaIntegrationMetricFactoryProps, BaseMonitoringProps
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "lambda_function": "lambdaFunction",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_functions_count_alarm": "addFailedFunctionsCountAlarm",
        "add_failed_functions_rate_alarm": "addFailedFunctionsRateAlarm",
        "add_timed_out_functions_count_alarm": "addTimedOutFunctionsCountAlarm",
    },
)
class StepFunctionLambdaIntegrationMonitoringProps(
    StepFunctionLambdaIntegrationMetricFactoryProps,
    BaseMonitoringProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_functions_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param lambda_function: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_functions_count_alarm: 
        :param add_failed_functions_rate_alarm: 
        :param add_timed_out_functions_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d2d7b1e2909623e368303672f6983450a565ae3ce6bef06f2b76416b15d30ae)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_functions_count_alarm", value=add_failed_functions_count_alarm, expected_type=type_hints["add_failed_functions_count_alarm"])
            check_type(argname="argument add_failed_functions_rate_alarm", value=add_failed_functions_rate_alarm, expected_type=type_hints["add_failed_functions_rate_alarm"])
            check_type(argname="argument add_timed_out_functions_count_alarm", value=add_timed_out_functions_count_alarm, expected_type=type_hints["add_timed_out_functions_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "lambda_function": lambda_function,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_functions_count_alarm is not None:
            self._values["add_failed_functions_count_alarm"] = add_failed_functions_count_alarm
        if add_failed_functions_rate_alarm is not None:
            self._values["add_failed_functions_rate_alarm"] = add_failed_functions_rate_alarm
        if add_timed_out_functions_count_alarm is not None:
            self._values["add_timed_out_functions_count_alarm"] = add_timed_out_functions_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.IFunction:
        '''
        :stability: experimental
        '''
        result = self._values.get("lambda_function")
        assert result is not None, "Required property 'lambda_function' is missing"
        return typing.cast(_aws_cdk_aws_lambda_ceddda9d.IFunction, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_functions_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_functions_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_functions_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_functions_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_timed_out_functions_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_timed_out_functions_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionLambdaIntegrationMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_aborted_execution_count_alarm": "addAbortedExecutionCountAlarm",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_execution_count_alarm": "addFailedExecutionCountAlarm",
        "add_failed_execution_rate_alarm": "addFailedExecutionRateAlarm",
        "add_min_started_execution_count_alarm": "addMinStartedExecutionCountAlarm",
        "add_throttled_execution_count_alarm": "addThrottledExecutionCountAlarm",
        "add_timed_out_execution_count_alarm": "addTimedOutExecutionCountAlarm",
    },
)
class StepFunctionMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_aborted_execution_count_alarm: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_execution_count_alarm: 
        :param add_failed_execution_rate_alarm: 
        :param add_min_started_execution_count_alarm: (experimental) Add minimum started execution count alarm for the stepfunctions.
        :param add_throttled_execution_count_alarm: 
        :param add_timed_out_execution_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1119e9f6665bb8ec0bfc46e8b0842e051616bb11fc481f4e3f168c6c9de3e5d4)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_aborted_execution_count_alarm", value=add_aborted_execution_count_alarm, expected_type=type_hints["add_aborted_execution_count_alarm"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_execution_count_alarm", value=add_failed_execution_count_alarm, expected_type=type_hints["add_failed_execution_count_alarm"])
            check_type(argname="argument add_failed_execution_rate_alarm", value=add_failed_execution_rate_alarm, expected_type=type_hints["add_failed_execution_rate_alarm"])
            check_type(argname="argument add_min_started_execution_count_alarm", value=add_min_started_execution_count_alarm, expected_type=type_hints["add_min_started_execution_count_alarm"])
            check_type(argname="argument add_throttled_execution_count_alarm", value=add_throttled_execution_count_alarm, expected_type=type_hints["add_throttled_execution_count_alarm"])
            check_type(argname="argument add_timed_out_execution_count_alarm", value=add_timed_out_execution_count_alarm, expected_type=type_hints["add_timed_out_execution_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_aborted_execution_count_alarm is not None:
            self._values["add_aborted_execution_count_alarm"] = add_aborted_execution_count_alarm
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_execution_count_alarm is not None:
            self._values["add_failed_execution_count_alarm"] = add_failed_execution_count_alarm
        if add_failed_execution_rate_alarm is not None:
            self._values["add_failed_execution_rate_alarm"] = add_failed_execution_rate_alarm
        if add_min_started_execution_count_alarm is not None:
            self._values["add_min_started_execution_count_alarm"] = add_min_started_execution_count_alarm
        if add_throttled_execution_count_alarm is not None:
            self._values["add_throttled_execution_count_alarm"] = add_throttled_execution_count_alarm
        if add_timed_out_execution_count_alarm is not None:
            self._values["add_timed_out_execution_count_alarm"] = add_timed_out_execution_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_aborted_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_aborted_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_execution_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_execution_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_min_started_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinRunningTaskCountThreshold]]:
        '''(experimental) Add minimum started execution count alarm for the stepfunctions.

        :stability: experimental
        '''
        result = self._values.get("add_min_started_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinRunningTaskCountThreshold]], result)

    @builtins.property
    def add_throttled_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttled_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_timed_out_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_timed_out_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionMonitoringProps",
    jsii_struct_bases=[StepFunctionMetricFactoryProps, StepFunctionMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "state_machine": "stateMachine",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_aborted_execution_count_alarm": "addAbortedExecutionCountAlarm",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_execution_count_alarm": "addFailedExecutionCountAlarm",
        "add_failed_execution_rate_alarm": "addFailedExecutionRateAlarm",
        "add_min_started_execution_count_alarm": "addMinStartedExecutionCountAlarm",
        "add_throttled_execution_count_alarm": "addThrottledExecutionCountAlarm",
        "add_timed_out_execution_count_alarm": "addTimedOutExecutionCountAlarm",
    },
)
class StepFunctionMonitoringProps(
    StepFunctionMetricFactoryProps,
    StepFunctionMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param state_machine: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_aborted_execution_count_alarm: 
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_execution_count_alarm: 
        :param add_failed_execution_rate_alarm: 
        :param add_min_started_execution_count_alarm: (experimental) Add minimum started execution count alarm for the stepfunctions.
        :param add_throttled_execution_count_alarm: 
        :param add_timed_out_execution_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4150cda6db7549a2d55053c64974a5dd7f488ca4db34a16b3e9fff4ceb8f7d68)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_aborted_execution_count_alarm", value=add_aborted_execution_count_alarm, expected_type=type_hints["add_aborted_execution_count_alarm"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_execution_count_alarm", value=add_failed_execution_count_alarm, expected_type=type_hints["add_failed_execution_count_alarm"])
            check_type(argname="argument add_failed_execution_rate_alarm", value=add_failed_execution_rate_alarm, expected_type=type_hints["add_failed_execution_rate_alarm"])
            check_type(argname="argument add_min_started_execution_count_alarm", value=add_min_started_execution_count_alarm, expected_type=type_hints["add_min_started_execution_count_alarm"])
            check_type(argname="argument add_throttled_execution_count_alarm", value=add_throttled_execution_count_alarm, expected_type=type_hints["add_throttled_execution_count_alarm"])
            check_type(argname="argument add_timed_out_execution_count_alarm", value=add_timed_out_execution_count_alarm, expected_type=type_hints["add_timed_out_execution_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "state_machine": state_machine,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_aborted_execution_count_alarm is not None:
            self._values["add_aborted_execution_count_alarm"] = add_aborted_execution_count_alarm
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_execution_count_alarm is not None:
            self._values["add_failed_execution_count_alarm"] = add_failed_execution_count_alarm
        if add_failed_execution_rate_alarm is not None:
            self._values["add_failed_execution_rate_alarm"] = add_failed_execution_rate_alarm
        if add_min_started_execution_count_alarm is not None:
            self._values["add_min_started_execution_count_alarm"] = add_min_started_execution_count_alarm
        if add_throttled_execution_count_alarm is not None:
            self._values["add_throttled_execution_count_alarm"] = add_throttled_execution_count_alarm
        if add_timed_out_execution_count_alarm is not None:
            self._values["add_timed_out_execution_count_alarm"] = add_timed_out_execution_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def state_machine(self) -> _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine:
        '''
        :stability: experimental
        '''
        result = self._values.get("state_machine")
        assert result is not None, "Required property 'state_machine' is missing"
        return typing.cast(_aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_aborted_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_aborted_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_execution_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_execution_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_min_started_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, MinRunningTaskCountThreshold]]:
        '''(experimental) Add minimum started execution count alarm for the stepfunctions.

        :stability: experimental
        '''
        result = self._values.get("add_min_started_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, MinRunningTaskCountThreshold]], result)

    @builtins.property
    def add_throttled_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_throttled_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_timed_out_execution_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_timed_out_execution_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.StepFunctionServiceIntegrationMonitoringProps",
    jsii_struct_bases=[
        StepFunctionServiceIntegrationMetricFactoryProps, BaseMonitoringProps
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "service_integration_resource_arn": "serviceIntegrationResourceArn",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_duration_p50_alarm": "addDurationP50Alarm",
        "add_duration_p90_alarm": "addDurationP90Alarm",
        "add_duration_p99_alarm": "addDurationP99Alarm",
        "add_failed_service_integrations_count_alarm": "addFailedServiceIntegrationsCountAlarm",
        "add_failed_service_integrations_rate_alarm": "addFailedServiceIntegrationsRateAlarm",
        "add_timed_out_service_integrations_count_alarm": "addTimedOutServiceIntegrationsCountAlarm",
    },
)
class StepFunctionServiceIntegrationMonitoringProps(
    StepFunctionServiceIntegrationMetricFactoryProps,
    BaseMonitoringProps,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        service_integration_resource_arn: builtins.str,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_failed_service_integrations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_timed_out_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param service_integration_resource_arn: 
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_duration_p50_alarm: 
        :param add_duration_p90_alarm: 
        :param add_duration_p99_alarm: 
        :param add_failed_service_integrations_count_alarm: 
        :param add_failed_service_integrations_rate_alarm: 
        :param add_timed_out_service_integrations_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b8898e4d32066cc2acbe2d726b10ddfd080749e42d59379a40bca5b433519f44)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument service_integration_resource_arn", value=service_integration_resource_arn, expected_type=type_hints["service_integration_resource_arn"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_duration_p50_alarm", value=add_duration_p50_alarm, expected_type=type_hints["add_duration_p50_alarm"])
            check_type(argname="argument add_duration_p90_alarm", value=add_duration_p90_alarm, expected_type=type_hints["add_duration_p90_alarm"])
            check_type(argname="argument add_duration_p99_alarm", value=add_duration_p99_alarm, expected_type=type_hints["add_duration_p99_alarm"])
            check_type(argname="argument add_failed_service_integrations_count_alarm", value=add_failed_service_integrations_count_alarm, expected_type=type_hints["add_failed_service_integrations_count_alarm"])
            check_type(argname="argument add_failed_service_integrations_rate_alarm", value=add_failed_service_integrations_rate_alarm, expected_type=type_hints["add_failed_service_integrations_rate_alarm"])
            check_type(argname="argument add_timed_out_service_integrations_count_alarm", value=add_timed_out_service_integrations_count_alarm, expected_type=type_hints["add_timed_out_service_integrations_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service_integration_resource_arn": service_integration_resource_arn,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_duration_p50_alarm is not None:
            self._values["add_duration_p50_alarm"] = add_duration_p50_alarm
        if add_duration_p90_alarm is not None:
            self._values["add_duration_p90_alarm"] = add_duration_p90_alarm
        if add_duration_p99_alarm is not None:
            self._values["add_duration_p99_alarm"] = add_duration_p99_alarm
        if add_failed_service_integrations_count_alarm is not None:
            self._values["add_failed_service_integrations_count_alarm"] = add_failed_service_integrations_count_alarm
        if add_failed_service_integrations_rate_alarm is not None:
            self._values["add_failed_service_integrations_rate_alarm"] = add_failed_service_integrations_rate_alarm
        if add_timed_out_service_integrations_count_alarm is not None:
            self._values["add_timed_out_service_integrations_count_alarm"] = add_timed_out_service_integrations_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_integration_resource_arn(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("service_integration_resource_arn")
        assert result is not None, "Required property 'service_integration_resource_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_duration_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_duration_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, DurationThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_duration_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, DurationThreshold]], result)

    @builtins.property
    def add_failed_service_integrations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_service_integrations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_failed_service_integrations_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_failed_service_integrations_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_timed_out_service_integrations_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_timed_out_service_integrations_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StepFunctionServiceIntegrationMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SyntheticsCanaryMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4xx_error_count_alarm": "add4xxErrorCountAlarm",
        "add4xx_error_rate_alarm": "add4xxErrorRateAlarm",
        "add5xx_fault_count_alarm": "add5xxFaultCountAlarm",
        "add5xx_fault_rate_alarm": "add5xxFaultRateAlarm",
        "add_average_latency_alarm": "addAverageLatencyAlarm",
    },
)
class SyntheticsCanaryMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4xx_error_count_alarm: 
        :param add4xx_error_rate_alarm: 
        :param add5xx_fault_count_alarm: 
        :param add5xx_fault_rate_alarm: 
        :param add_average_latency_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0b367f8fefeb755686784efb64b65163152ae36d8a2334aeef0359ce4d5005da)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4xx_error_count_alarm", value=add4xx_error_count_alarm, expected_type=type_hints["add4xx_error_count_alarm"])
            check_type(argname="argument add4xx_error_rate_alarm", value=add4xx_error_rate_alarm, expected_type=type_hints["add4xx_error_rate_alarm"])
            check_type(argname="argument add5xx_fault_count_alarm", value=add5xx_fault_count_alarm, expected_type=type_hints["add5xx_fault_count_alarm"])
            check_type(argname="argument add5xx_fault_rate_alarm", value=add5xx_fault_rate_alarm, expected_type=type_hints["add5xx_fault_rate_alarm"])
            check_type(argname="argument add_average_latency_alarm", value=add_average_latency_alarm, expected_type=type_hints["add_average_latency_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4xx_error_count_alarm is not None:
            self._values["add4xx_error_count_alarm"] = add4xx_error_count_alarm
        if add4xx_error_rate_alarm is not None:
            self._values["add4xx_error_rate_alarm"] = add4xx_error_rate_alarm
        if add5xx_fault_count_alarm is not None:
            self._values["add5xx_fault_count_alarm"] = add5xx_fault_count_alarm
        if add5xx_fault_rate_alarm is not None:
            self._values["add5xx_fault_rate_alarm"] = add5xx_fault_rate_alarm
        if add_average_latency_alarm is not None:
            self._values["add_average_latency_alarm"] = add_average_latency_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_average_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SyntheticsCanaryMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.SyntheticsCanaryMonitoringProps",
    jsii_struct_bases=[
        SyntheticsCanaryMetricFactoryProps, SyntheticsCanaryMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "canary": "canary",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4xx_error_count_alarm": "add4xxErrorCountAlarm",
        "add4xx_error_rate_alarm": "add4xxErrorRateAlarm",
        "add5xx_fault_count_alarm": "add5xxFaultCountAlarm",
        "add5xx_fault_rate_alarm": "add5xxFaultRateAlarm",
        "add_average_latency_alarm": "addAverageLatencyAlarm",
    },
)
class SyntheticsCanaryMonitoringProps(
    SyntheticsCanaryMetricFactoryProps,
    SyntheticsCanaryMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param canary: (experimental) CloudWatch Canary to monitor.
        :param rate_computation_method: (experimental) Method used to calculate relative rates. Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4xx_error_count_alarm: 
        :param add4xx_error_rate_alarm: 
        :param add5xx_fault_count_alarm: 
        :param add5xx_fault_rate_alarm: 
        :param add_average_latency_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__469e6d4d399badb350095dbabd03e4abc53577bbb1717344ec4ba7a1692148a5)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument canary", value=canary, expected_type=type_hints["canary"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4xx_error_count_alarm", value=add4xx_error_count_alarm, expected_type=type_hints["add4xx_error_count_alarm"])
            check_type(argname="argument add4xx_error_rate_alarm", value=add4xx_error_rate_alarm, expected_type=type_hints["add4xx_error_rate_alarm"])
            check_type(argname="argument add5xx_fault_count_alarm", value=add5xx_fault_count_alarm, expected_type=type_hints["add5xx_fault_count_alarm"])
            check_type(argname="argument add5xx_fault_rate_alarm", value=add5xx_fault_rate_alarm, expected_type=type_hints["add5xx_fault_rate_alarm"])
            check_type(argname="argument add_average_latency_alarm", value=add_average_latency_alarm, expected_type=type_hints["add_average_latency_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "canary": canary,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4xx_error_count_alarm is not None:
            self._values["add4xx_error_count_alarm"] = add4xx_error_count_alarm
        if add4xx_error_rate_alarm is not None:
            self._values["add4xx_error_rate_alarm"] = add4xx_error_rate_alarm
        if add5xx_fault_count_alarm is not None:
            self._values["add5xx_fault_count_alarm"] = add5xx_fault_count_alarm
        if add5xx_fault_rate_alarm is not None:
            self._values["add5xx_fault_rate_alarm"] = add5xx_fault_rate_alarm
        if add_average_latency_alarm is not None:
            self._values["add_average_latency_alarm"] = add_average_latency_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def canary(self) -> _aws_cdk_aws_synthetics_ceddda9d.Canary:
        '''(experimental) CloudWatch Canary to monitor.

        :stability: experimental
        '''
        result = self._values.get("canary")
        assert result is not None, "Required property 'canary' is missing"
        return typing.cast(_aws_cdk_aws_synthetics_ceddda9d.Canary, result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''(experimental) Method used to calculate relative rates.

        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_average_latency_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_average_latency_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SyntheticsCanaryMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.WafV2MonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class WafV2MonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ebfbca8b6aa57717f044140e97941cb2cef3741a4102249def6b26af7c71ff4)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "WafV2MonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.WafV2MonitoringProps",
    jsii_struct_bases=[WafV2MetricFactoryProps, WafV2MonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "acl": "acl",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_blocked_requests_count_alarm": "addBlockedRequestsCountAlarm",
        "add_blocked_requests_rate_alarm": "addBlockedRequestsRateAlarm",
    },
)
class WafV2MonitoringProps(WafV2MetricFactoryProps, WafV2MonitoringOptions):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_blocked_requests_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_blocked_requests_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param acl: (experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_blocked_requests_count_alarm: 
        :param add_blocked_requests_rate_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7075b042489cfae6d06cb7ff5692a6b80a22e550fd750f2740a85a2e74eb6ae2)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_blocked_requests_count_alarm", value=add_blocked_requests_count_alarm, expected_type=type_hints["add_blocked_requests_count_alarm"])
            check_type(argname="argument add_blocked_requests_rate_alarm", value=add_blocked_requests_rate_alarm, expected_type=type_hints["add_blocked_requests_rate_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "acl": acl,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_blocked_requests_count_alarm is not None:
            self._values["add_blocked_requests_count_alarm"] = add_blocked_requests_count_alarm
        if add_blocked_requests_rate_alarm is not None:
            self._values["add_blocked_requests_rate_alarm"] = add_blocked_requests_rate_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def acl(self) -> _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL:
        '''(experimental) Note that the "region" prop is required if this has a "REGIONAL" scope.

        :stability: experimental
        '''
        result = self._values.get("acl")
        assert result is not None, "Required property 'acl' is missing"
        return typing.cast(_aws_cdk_aws_wafv2_ceddda9d.CfnWebACL, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_blocked_requests_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_blocked_requests_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add_blocked_requests_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_blocked_requests_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "WafV2MonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4_xx_error_count_alarm": "add4XXErrorCountAlarm",
        "add4_xx_error_rate_alarm": "add4XXErrorRateAlarm",
        "add5_xx_fault_count_alarm": "add5XXFaultCountAlarm",
        "add5_xx_fault_rate_alarm": "add5XXFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_average_alarm": "addLatencyAverageAlarm",
        "add_latency_p100_alarm": "addLatencyP100Alarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p70_alarm": "addLatencyP70Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p95_alarm": "addLatencyP95Alarm",
        "add_latency_p9999_alarm": "addLatencyP9999Alarm",
        "add_latency_p999_alarm": "addLatencyP999Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_latency_tm50_alarm": "addLatencyTM50Alarm",
        "add_latency_tm70_alarm": "addLatencyTM70Alarm",
        "add_latency_tm90_alarm": "addLatencyTM90Alarm",
        "add_latency_tm95_alarm": "addLatencyTM95Alarm",
        "add_latency_tm95_outlier_alarm": "addLatencyTM95OutlierAlarm",
        "add_latency_tm9999_alarm": "addLatencyTM9999Alarm",
        "add_latency_tm9999_outlier_alarm": "addLatencyTM9999OutlierAlarm",
        "add_latency_tm999_alarm": "addLatencyTM999Alarm",
        "add_latency_tm999_outlier_alarm": "addLatencyTM999OutlierAlarm",
        "add_latency_tm99_alarm": "addLatencyTM99Alarm",
        "add_latency_tm99_outlier_alarm": "addLatencyTM99OutlierAlarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "latency_types_to_render": "latencyTypesToRender",
    },
)
class ApiGatewayMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42dd4a21cb03789bd212240ccf2ec445cfad151a5fd165d1cf8663a2be045eca)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4_xx_error_count_alarm", value=add4_xx_error_count_alarm, expected_type=type_hints["add4_xx_error_count_alarm"])
            check_type(argname="argument add4_xx_error_rate_alarm", value=add4_xx_error_rate_alarm, expected_type=type_hints["add4_xx_error_rate_alarm"])
            check_type(argname="argument add5_xx_fault_count_alarm", value=add5_xx_fault_count_alarm, expected_type=type_hints["add5_xx_fault_count_alarm"])
            check_type(argname="argument add5_xx_fault_rate_alarm", value=add5_xx_fault_rate_alarm, expected_type=type_hints["add5_xx_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_average_alarm", value=add_latency_average_alarm, expected_type=type_hints["add_latency_average_alarm"])
            check_type(argname="argument add_latency_p100_alarm", value=add_latency_p100_alarm, expected_type=type_hints["add_latency_p100_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p70_alarm", value=add_latency_p70_alarm, expected_type=type_hints["add_latency_p70_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p95_alarm", value=add_latency_p95_alarm, expected_type=type_hints["add_latency_p95_alarm"])
            check_type(argname="argument add_latency_p9999_alarm", value=add_latency_p9999_alarm, expected_type=type_hints["add_latency_p9999_alarm"])
            check_type(argname="argument add_latency_p999_alarm", value=add_latency_p999_alarm, expected_type=type_hints["add_latency_p999_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_latency_tm50_alarm", value=add_latency_tm50_alarm, expected_type=type_hints["add_latency_tm50_alarm"])
            check_type(argname="argument add_latency_tm70_alarm", value=add_latency_tm70_alarm, expected_type=type_hints["add_latency_tm70_alarm"])
            check_type(argname="argument add_latency_tm90_alarm", value=add_latency_tm90_alarm, expected_type=type_hints["add_latency_tm90_alarm"])
            check_type(argname="argument add_latency_tm95_alarm", value=add_latency_tm95_alarm, expected_type=type_hints["add_latency_tm95_alarm"])
            check_type(argname="argument add_latency_tm95_outlier_alarm", value=add_latency_tm95_outlier_alarm, expected_type=type_hints["add_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_latency_tm9999_alarm", value=add_latency_tm9999_alarm, expected_type=type_hints["add_latency_tm9999_alarm"])
            check_type(argname="argument add_latency_tm9999_outlier_alarm", value=add_latency_tm9999_outlier_alarm, expected_type=type_hints["add_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_latency_tm999_alarm", value=add_latency_tm999_alarm, expected_type=type_hints["add_latency_tm999_alarm"])
            check_type(argname="argument add_latency_tm999_outlier_alarm", value=add_latency_tm999_outlier_alarm, expected_type=type_hints["add_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_latency_tm99_alarm", value=add_latency_tm99_alarm, expected_type=type_hints["add_latency_tm99_alarm"])
            check_type(argname="argument add_latency_tm99_outlier_alarm", value=add_latency_tm99_outlier_alarm, expected_type=type_hints["add_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument latency_types_to_render", value=latency_types_to_render, expected_type=type_hints["latency_types_to_render"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4_xx_error_count_alarm is not None:
            self._values["add4_xx_error_count_alarm"] = add4_xx_error_count_alarm
        if add4_xx_error_rate_alarm is not None:
            self._values["add4_xx_error_rate_alarm"] = add4_xx_error_rate_alarm
        if add5_xx_fault_count_alarm is not None:
            self._values["add5_xx_fault_count_alarm"] = add5_xx_fault_count_alarm
        if add5_xx_fault_rate_alarm is not None:
            self._values["add5_xx_fault_rate_alarm"] = add5_xx_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_average_alarm is not None:
            self._values["add_latency_average_alarm"] = add_latency_average_alarm
        if add_latency_p100_alarm is not None:
            self._values["add_latency_p100_alarm"] = add_latency_p100_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p70_alarm is not None:
            self._values["add_latency_p70_alarm"] = add_latency_p70_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p95_alarm is not None:
            self._values["add_latency_p95_alarm"] = add_latency_p95_alarm
        if add_latency_p9999_alarm is not None:
            self._values["add_latency_p9999_alarm"] = add_latency_p9999_alarm
        if add_latency_p999_alarm is not None:
            self._values["add_latency_p999_alarm"] = add_latency_p999_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_latency_tm50_alarm is not None:
            self._values["add_latency_tm50_alarm"] = add_latency_tm50_alarm
        if add_latency_tm70_alarm is not None:
            self._values["add_latency_tm70_alarm"] = add_latency_tm70_alarm
        if add_latency_tm90_alarm is not None:
            self._values["add_latency_tm90_alarm"] = add_latency_tm90_alarm
        if add_latency_tm95_alarm is not None:
            self._values["add_latency_tm95_alarm"] = add_latency_tm95_alarm
        if add_latency_tm95_outlier_alarm is not None:
            self._values["add_latency_tm95_outlier_alarm"] = add_latency_tm95_outlier_alarm
        if add_latency_tm9999_alarm is not None:
            self._values["add_latency_tm9999_alarm"] = add_latency_tm9999_alarm
        if add_latency_tm9999_outlier_alarm is not None:
            self._values["add_latency_tm9999_outlier_alarm"] = add_latency_tm9999_outlier_alarm
        if add_latency_tm999_alarm is not None:
            self._values["add_latency_tm999_alarm"] = add_latency_tm999_alarm
        if add_latency_tm999_outlier_alarm is not None:
            self._values["add_latency_tm999_outlier_alarm"] = add_latency_tm999_outlier_alarm
        if add_latency_tm99_alarm is not None:
            self._values["add_latency_tm99_alarm"] = add_latency_tm99_alarm
        if add_latency_tm99_outlier_alarm is not None:
            self._values["add_latency_tm99_outlier_alarm"] = add_latency_tm99_outlier_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if latency_types_to_render is not None:
            self._values["latency_types_to_render"] = latency_types_to_render

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4_xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4_xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5_xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5_xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def latency_types_to_render(self) -> typing.Optional[typing.List[LatencyType]]:
        '''(experimental) You can specify what latency types you want to be rendered in the dashboards.

        Note: any latency type with an alarm will be also added automatically.
        If the list is undefined, default values will be shown.
        If the list is empty, only the latency types with an alarm will be shown (if any).

        :default: - p50, p90, p99 (

        :see: DefaultLatencyTypesToRender)
        :stability: experimental
        '''
        result = self._values.get("latency_types_to_render")
        return typing.cast(typing.Optional[typing.List[LatencyType]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayMonitoringProps",
    jsii_struct_bases=[ApiGatewayMetricFactoryProps, ApiGatewayMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "api": "api",
        "api_method": "apiMethod",
        "api_resource": "apiResource",
        "api_stage": "apiStage",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4_xx_error_count_alarm": "add4XXErrorCountAlarm",
        "add4_xx_error_rate_alarm": "add4XXErrorRateAlarm",
        "add5_xx_fault_count_alarm": "add5XXFaultCountAlarm",
        "add5_xx_fault_rate_alarm": "add5XXFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_average_alarm": "addLatencyAverageAlarm",
        "add_latency_p100_alarm": "addLatencyP100Alarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p70_alarm": "addLatencyP70Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p95_alarm": "addLatencyP95Alarm",
        "add_latency_p9999_alarm": "addLatencyP9999Alarm",
        "add_latency_p999_alarm": "addLatencyP999Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_latency_tm50_alarm": "addLatencyTM50Alarm",
        "add_latency_tm70_alarm": "addLatencyTM70Alarm",
        "add_latency_tm90_alarm": "addLatencyTM90Alarm",
        "add_latency_tm95_alarm": "addLatencyTM95Alarm",
        "add_latency_tm95_outlier_alarm": "addLatencyTM95OutlierAlarm",
        "add_latency_tm9999_alarm": "addLatencyTM9999Alarm",
        "add_latency_tm9999_outlier_alarm": "addLatencyTM9999OutlierAlarm",
        "add_latency_tm999_alarm": "addLatencyTM999Alarm",
        "add_latency_tm999_outlier_alarm": "addLatencyTM999OutlierAlarm",
        "add_latency_tm99_alarm": "addLatencyTM99Alarm",
        "add_latency_tm99_outlier_alarm": "addLatencyTM99OutlierAlarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "latency_types_to_render": "latencyTypesToRender",
    },
)
class ApiGatewayMonitoringProps(
    ApiGatewayMetricFactoryProps,
    ApiGatewayMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param api: (experimental) API to monitor.
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - prod
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c42d46bd924daca5f765f03a570200a4b4019939fabcdb69940282c19f7ff46)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument api_method", value=api_method, expected_type=type_hints["api_method"])
            check_type(argname="argument api_resource", value=api_resource, expected_type=type_hints["api_resource"])
            check_type(argname="argument api_stage", value=api_stage, expected_type=type_hints["api_stage"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4_xx_error_count_alarm", value=add4_xx_error_count_alarm, expected_type=type_hints["add4_xx_error_count_alarm"])
            check_type(argname="argument add4_xx_error_rate_alarm", value=add4_xx_error_rate_alarm, expected_type=type_hints["add4_xx_error_rate_alarm"])
            check_type(argname="argument add5_xx_fault_count_alarm", value=add5_xx_fault_count_alarm, expected_type=type_hints["add5_xx_fault_count_alarm"])
            check_type(argname="argument add5_xx_fault_rate_alarm", value=add5_xx_fault_rate_alarm, expected_type=type_hints["add5_xx_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_average_alarm", value=add_latency_average_alarm, expected_type=type_hints["add_latency_average_alarm"])
            check_type(argname="argument add_latency_p100_alarm", value=add_latency_p100_alarm, expected_type=type_hints["add_latency_p100_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p70_alarm", value=add_latency_p70_alarm, expected_type=type_hints["add_latency_p70_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p95_alarm", value=add_latency_p95_alarm, expected_type=type_hints["add_latency_p95_alarm"])
            check_type(argname="argument add_latency_p9999_alarm", value=add_latency_p9999_alarm, expected_type=type_hints["add_latency_p9999_alarm"])
            check_type(argname="argument add_latency_p999_alarm", value=add_latency_p999_alarm, expected_type=type_hints["add_latency_p999_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_latency_tm50_alarm", value=add_latency_tm50_alarm, expected_type=type_hints["add_latency_tm50_alarm"])
            check_type(argname="argument add_latency_tm70_alarm", value=add_latency_tm70_alarm, expected_type=type_hints["add_latency_tm70_alarm"])
            check_type(argname="argument add_latency_tm90_alarm", value=add_latency_tm90_alarm, expected_type=type_hints["add_latency_tm90_alarm"])
            check_type(argname="argument add_latency_tm95_alarm", value=add_latency_tm95_alarm, expected_type=type_hints["add_latency_tm95_alarm"])
            check_type(argname="argument add_latency_tm95_outlier_alarm", value=add_latency_tm95_outlier_alarm, expected_type=type_hints["add_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_latency_tm9999_alarm", value=add_latency_tm9999_alarm, expected_type=type_hints["add_latency_tm9999_alarm"])
            check_type(argname="argument add_latency_tm9999_outlier_alarm", value=add_latency_tm9999_outlier_alarm, expected_type=type_hints["add_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_latency_tm999_alarm", value=add_latency_tm999_alarm, expected_type=type_hints["add_latency_tm999_alarm"])
            check_type(argname="argument add_latency_tm999_outlier_alarm", value=add_latency_tm999_outlier_alarm, expected_type=type_hints["add_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_latency_tm99_alarm", value=add_latency_tm99_alarm, expected_type=type_hints["add_latency_tm99_alarm"])
            check_type(argname="argument add_latency_tm99_outlier_alarm", value=add_latency_tm99_outlier_alarm, expected_type=type_hints["add_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument latency_types_to_render", value=latency_types_to_render, expected_type=type_hints["latency_types_to_render"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if api_method is not None:
            self._values["api_method"] = api_method
        if api_resource is not None:
            self._values["api_resource"] = api_resource
        if api_stage is not None:
            self._values["api_stage"] = api_stage
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4_xx_error_count_alarm is not None:
            self._values["add4_xx_error_count_alarm"] = add4_xx_error_count_alarm
        if add4_xx_error_rate_alarm is not None:
            self._values["add4_xx_error_rate_alarm"] = add4_xx_error_rate_alarm
        if add5_xx_fault_count_alarm is not None:
            self._values["add5_xx_fault_count_alarm"] = add5_xx_fault_count_alarm
        if add5_xx_fault_rate_alarm is not None:
            self._values["add5_xx_fault_rate_alarm"] = add5_xx_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_average_alarm is not None:
            self._values["add_latency_average_alarm"] = add_latency_average_alarm
        if add_latency_p100_alarm is not None:
            self._values["add_latency_p100_alarm"] = add_latency_p100_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p70_alarm is not None:
            self._values["add_latency_p70_alarm"] = add_latency_p70_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p95_alarm is not None:
            self._values["add_latency_p95_alarm"] = add_latency_p95_alarm
        if add_latency_p9999_alarm is not None:
            self._values["add_latency_p9999_alarm"] = add_latency_p9999_alarm
        if add_latency_p999_alarm is not None:
            self._values["add_latency_p999_alarm"] = add_latency_p999_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_latency_tm50_alarm is not None:
            self._values["add_latency_tm50_alarm"] = add_latency_tm50_alarm
        if add_latency_tm70_alarm is not None:
            self._values["add_latency_tm70_alarm"] = add_latency_tm70_alarm
        if add_latency_tm90_alarm is not None:
            self._values["add_latency_tm90_alarm"] = add_latency_tm90_alarm
        if add_latency_tm95_alarm is not None:
            self._values["add_latency_tm95_alarm"] = add_latency_tm95_alarm
        if add_latency_tm95_outlier_alarm is not None:
            self._values["add_latency_tm95_outlier_alarm"] = add_latency_tm95_outlier_alarm
        if add_latency_tm9999_alarm is not None:
            self._values["add_latency_tm9999_alarm"] = add_latency_tm9999_alarm
        if add_latency_tm9999_outlier_alarm is not None:
            self._values["add_latency_tm9999_outlier_alarm"] = add_latency_tm9999_outlier_alarm
        if add_latency_tm999_alarm is not None:
            self._values["add_latency_tm999_alarm"] = add_latency_tm999_alarm
        if add_latency_tm999_outlier_alarm is not None:
            self._values["add_latency_tm999_outlier_alarm"] = add_latency_tm999_outlier_alarm
        if add_latency_tm99_alarm is not None:
            self._values["add_latency_tm99_alarm"] = add_latency_tm99_alarm
        if add_latency_tm99_outlier_alarm is not None:
            self._values["add_latency_tm99_outlier_alarm"] = add_latency_tm99_outlier_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if latency_types_to_render is not None:
            self._values["latency_types_to_render"] = latency_types_to_render

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_apigateway_ceddda9d.IRestApi:
        '''(experimental) API to monitor.

        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_apigateway_ceddda9d.IRestApi, result)

    @builtins.property
    def api_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_resource(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_resource")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_stage(self) -> typing.Optional[builtins.str]:
        '''
        :default: - prod

        :stability: experimental
        '''
        result = self._values.get("api_stage")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4_xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4_xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5_xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5_xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def latency_types_to_render(self) -> typing.Optional[typing.List[LatencyType]]:
        '''(experimental) You can specify what latency types you want to be rendered in the dashboards.

        Note: any latency type with an alarm will be also added automatically.
        If the list is undefined, default values will be shown.
        If the list is empty, only the latency types with an alarm will be shown (if any).

        :default: - p50, p90, p99 (

        :see: DefaultLatencyTypesToRender)
        :stability: experimental
        '''
        result = self._values.get("latency_types_to_render")
        return typing.cast(typing.Optional[typing.List[LatencyType]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayV2MonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4xx_count_alarm": "add4xxCountAlarm",
        "add4xx_rate_alarm": "add4xxRateAlarm",
        "add5xx_count_alarm": "add5xxCountAlarm",
        "add5xx_rate_alarm": "add5xxRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_integration_latency_average_alarm": "addIntegrationLatencyAverageAlarm",
        "add_integration_latency_p100_alarm": "addIntegrationLatencyP100Alarm",
        "add_integration_latency_p50_alarm": "addIntegrationLatencyP50Alarm",
        "add_integration_latency_p70_alarm": "addIntegrationLatencyP70Alarm",
        "add_integration_latency_p90_alarm": "addIntegrationLatencyP90Alarm",
        "add_integration_latency_p95_alarm": "addIntegrationLatencyP95Alarm",
        "add_integration_latency_p9999_alarm": "addIntegrationLatencyP9999Alarm",
        "add_integration_latency_p999_alarm": "addIntegrationLatencyP999Alarm",
        "add_integration_latency_p99_alarm": "addIntegrationLatencyP99Alarm",
        "add_integration_latency_tm50_alarm": "addIntegrationLatencyTM50Alarm",
        "add_integration_latency_tm70_alarm": "addIntegrationLatencyTM70Alarm",
        "add_integration_latency_tm90_alarm": "addIntegrationLatencyTM90Alarm",
        "add_integration_latency_tm95_alarm": "addIntegrationLatencyTM95Alarm",
        "add_integration_latency_tm95_outlier_alarm": "addIntegrationLatencyTM95OutlierAlarm",
        "add_integration_latency_tm9999_alarm": "addIntegrationLatencyTM9999Alarm",
        "add_integration_latency_tm9999_outlier_alarm": "addIntegrationLatencyTM9999OutlierAlarm",
        "add_integration_latency_tm999_alarm": "addIntegrationLatencyTM999Alarm",
        "add_integration_latency_tm999_outlier_alarm": "addIntegrationLatencyTM999OutlierAlarm",
        "add_integration_latency_tm99_alarm": "addIntegrationLatencyTM99Alarm",
        "add_integration_latency_tm99_outlier_alarm": "addIntegrationLatencyTM99OutlierAlarm",
        "add_latency_average_alarm": "addLatencyAverageAlarm",
        "add_latency_p100_alarm": "addLatencyP100Alarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p70_alarm": "addLatencyP70Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p95_alarm": "addLatencyP95Alarm",
        "add_latency_p9999_alarm": "addLatencyP9999Alarm",
        "add_latency_p999_alarm": "addLatencyP999Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_latency_tm50_alarm": "addLatencyTM50Alarm",
        "add_latency_tm70_alarm": "addLatencyTM70Alarm",
        "add_latency_tm90_alarm": "addLatencyTM90Alarm",
        "add_latency_tm95_alarm": "addLatencyTM95Alarm",
        "add_latency_tm95_outlier_alarm": "addLatencyTM95OutlierAlarm",
        "add_latency_tm9999_alarm": "addLatencyTM9999Alarm",
        "add_latency_tm9999_outlier_alarm": "addLatencyTM9999OutlierAlarm",
        "add_latency_tm999_alarm": "addLatencyTM999Alarm",
        "add_latency_tm999_outlier_alarm": "addLatencyTM999OutlierAlarm",
        "add_latency_tm99_alarm": "addLatencyTM99Alarm",
        "add_latency_tm99_outlier_alarm": "addLatencyTM99OutlierAlarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "latency_types_to_render": "latencyTypesToRender",
    },
)
class ApiGatewayV2MonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4xx_count_alarm: 
        :param add4xx_rate_alarm: 
        :param add5xx_count_alarm: 
        :param add5xx_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_integration_latency_average_alarm: 
        :param add_integration_latency_p100_alarm: 
        :param add_integration_latency_p50_alarm: 
        :param add_integration_latency_p70_alarm: 
        :param add_integration_latency_p90_alarm: 
        :param add_integration_latency_p95_alarm: 
        :param add_integration_latency_p9999_alarm: 
        :param add_integration_latency_p999_alarm: 
        :param add_integration_latency_p99_alarm: 
        :param add_integration_latency_tm50_alarm: 
        :param add_integration_latency_tm70_alarm: 
        :param add_integration_latency_tm90_alarm: 
        :param add_integration_latency_tm95_alarm: 
        :param add_integration_latency_tm95_outlier_alarm: 
        :param add_integration_latency_tm9999_alarm: 
        :param add_integration_latency_tm9999_outlier_alarm: 
        :param add_integration_latency_tm999_alarm: 
        :param add_integration_latency_tm999_outlier_alarm: 
        :param add_integration_latency_tm99_alarm: 
        :param add_integration_latency_tm99_outlier_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7df9fbdfb66638a7b7ea1397c791fafa4f5829038225f6419b693b04c92381e)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4xx_count_alarm", value=add4xx_count_alarm, expected_type=type_hints["add4xx_count_alarm"])
            check_type(argname="argument add4xx_rate_alarm", value=add4xx_rate_alarm, expected_type=type_hints["add4xx_rate_alarm"])
            check_type(argname="argument add5xx_count_alarm", value=add5xx_count_alarm, expected_type=type_hints["add5xx_count_alarm"])
            check_type(argname="argument add5xx_rate_alarm", value=add5xx_rate_alarm, expected_type=type_hints["add5xx_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_integration_latency_average_alarm", value=add_integration_latency_average_alarm, expected_type=type_hints["add_integration_latency_average_alarm"])
            check_type(argname="argument add_integration_latency_p100_alarm", value=add_integration_latency_p100_alarm, expected_type=type_hints["add_integration_latency_p100_alarm"])
            check_type(argname="argument add_integration_latency_p50_alarm", value=add_integration_latency_p50_alarm, expected_type=type_hints["add_integration_latency_p50_alarm"])
            check_type(argname="argument add_integration_latency_p70_alarm", value=add_integration_latency_p70_alarm, expected_type=type_hints["add_integration_latency_p70_alarm"])
            check_type(argname="argument add_integration_latency_p90_alarm", value=add_integration_latency_p90_alarm, expected_type=type_hints["add_integration_latency_p90_alarm"])
            check_type(argname="argument add_integration_latency_p95_alarm", value=add_integration_latency_p95_alarm, expected_type=type_hints["add_integration_latency_p95_alarm"])
            check_type(argname="argument add_integration_latency_p9999_alarm", value=add_integration_latency_p9999_alarm, expected_type=type_hints["add_integration_latency_p9999_alarm"])
            check_type(argname="argument add_integration_latency_p999_alarm", value=add_integration_latency_p999_alarm, expected_type=type_hints["add_integration_latency_p999_alarm"])
            check_type(argname="argument add_integration_latency_p99_alarm", value=add_integration_latency_p99_alarm, expected_type=type_hints["add_integration_latency_p99_alarm"])
            check_type(argname="argument add_integration_latency_tm50_alarm", value=add_integration_latency_tm50_alarm, expected_type=type_hints["add_integration_latency_tm50_alarm"])
            check_type(argname="argument add_integration_latency_tm70_alarm", value=add_integration_latency_tm70_alarm, expected_type=type_hints["add_integration_latency_tm70_alarm"])
            check_type(argname="argument add_integration_latency_tm90_alarm", value=add_integration_latency_tm90_alarm, expected_type=type_hints["add_integration_latency_tm90_alarm"])
            check_type(argname="argument add_integration_latency_tm95_alarm", value=add_integration_latency_tm95_alarm, expected_type=type_hints["add_integration_latency_tm95_alarm"])
            check_type(argname="argument add_integration_latency_tm95_outlier_alarm", value=add_integration_latency_tm95_outlier_alarm, expected_type=type_hints["add_integration_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm9999_alarm", value=add_integration_latency_tm9999_alarm, expected_type=type_hints["add_integration_latency_tm9999_alarm"])
            check_type(argname="argument add_integration_latency_tm9999_outlier_alarm", value=add_integration_latency_tm9999_outlier_alarm, expected_type=type_hints["add_integration_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm999_alarm", value=add_integration_latency_tm999_alarm, expected_type=type_hints["add_integration_latency_tm999_alarm"])
            check_type(argname="argument add_integration_latency_tm999_outlier_alarm", value=add_integration_latency_tm999_outlier_alarm, expected_type=type_hints["add_integration_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm99_alarm", value=add_integration_latency_tm99_alarm, expected_type=type_hints["add_integration_latency_tm99_alarm"])
            check_type(argname="argument add_integration_latency_tm99_outlier_alarm", value=add_integration_latency_tm99_outlier_alarm, expected_type=type_hints["add_integration_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_latency_average_alarm", value=add_latency_average_alarm, expected_type=type_hints["add_latency_average_alarm"])
            check_type(argname="argument add_latency_p100_alarm", value=add_latency_p100_alarm, expected_type=type_hints["add_latency_p100_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p70_alarm", value=add_latency_p70_alarm, expected_type=type_hints["add_latency_p70_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p95_alarm", value=add_latency_p95_alarm, expected_type=type_hints["add_latency_p95_alarm"])
            check_type(argname="argument add_latency_p9999_alarm", value=add_latency_p9999_alarm, expected_type=type_hints["add_latency_p9999_alarm"])
            check_type(argname="argument add_latency_p999_alarm", value=add_latency_p999_alarm, expected_type=type_hints["add_latency_p999_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_latency_tm50_alarm", value=add_latency_tm50_alarm, expected_type=type_hints["add_latency_tm50_alarm"])
            check_type(argname="argument add_latency_tm70_alarm", value=add_latency_tm70_alarm, expected_type=type_hints["add_latency_tm70_alarm"])
            check_type(argname="argument add_latency_tm90_alarm", value=add_latency_tm90_alarm, expected_type=type_hints["add_latency_tm90_alarm"])
            check_type(argname="argument add_latency_tm95_alarm", value=add_latency_tm95_alarm, expected_type=type_hints["add_latency_tm95_alarm"])
            check_type(argname="argument add_latency_tm95_outlier_alarm", value=add_latency_tm95_outlier_alarm, expected_type=type_hints["add_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_latency_tm9999_alarm", value=add_latency_tm9999_alarm, expected_type=type_hints["add_latency_tm9999_alarm"])
            check_type(argname="argument add_latency_tm9999_outlier_alarm", value=add_latency_tm9999_outlier_alarm, expected_type=type_hints["add_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_latency_tm999_alarm", value=add_latency_tm999_alarm, expected_type=type_hints["add_latency_tm999_alarm"])
            check_type(argname="argument add_latency_tm999_outlier_alarm", value=add_latency_tm999_outlier_alarm, expected_type=type_hints["add_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_latency_tm99_alarm", value=add_latency_tm99_alarm, expected_type=type_hints["add_latency_tm99_alarm"])
            check_type(argname="argument add_latency_tm99_outlier_alarm", value=add_latency_tm99_outlier_alarm, expected_type=type_hints["add_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument latency_types_to_render", value=latency_types_to_render, expected_type=type_hints["latency_types_to_render"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4xx_count_alarm is not None:
            self._values["add4xx_count_alarm"] = add4xx_count_alarm
        if add4xx_rate_alarm is not None:
            self._values["add4xx_rate_alarm"] = add4xx_rate_alarm
        if add5xx_count_alarm is not None:
            self._values["add5xx_count_alarm"] = add5xx_count_alarm
        if add5xx_rate_alarm is not None:
            self._values["add5xx_rate_alarm"] = add5xx_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_integration_latency_average_alarm is not None:
            self._values["add_integration_latency_average_alarm"] = add_integration_latency_average_alarm
        if add_integration_latency_p100_alarm is not None:
            self._values["add_integration_latency_p100_alarm"] = add_integration_latency_p100_alarm
        if add_integration_latency_p50_alarm is not None:
            self._values["add_integration_latency_p50_alarm"] = add_integration_latency_p50_alarm
        if add_integration_latency_p70_alarm is not None:
            self._values["add_integration_latency_p70_alarm"] = add_integration_latency_p70_alarm
        if add_integration_latency_p90_alarm is not None:
            self._values["add_integration_latency_p90_alarm"] = add_integration_latency_p90_alarm
        if add_integration_latency_p95_alarm is not None:
            self._values["add_integration_latency_p95_alarm"] = add_integration_latency_p95_alarm
        if add_integration_latency_p9999_alarm is not None:
            self._values["add_integration_latency_p9999_alarm"] = add_integration_latency_p9999_alarm
        if add_integration_latency_p999_alarm is not None:
            self._values["add_integration_latency_p999_alarm"] = add_integration_latency_p999_alarm
        if add_integration_latency_p99_alarm is not None:
            self._values["add_integration_latency_p99_alarm"] = add_integration_latency_p99_alarm
        if add_integration_latency_tm50_alarm is not None:
            self._values["add_integration_latency_tm50_alarm"] = add_integration_latency_tm50_alarm
        if add_integration_latency_tm70_alarm is not None:
            self._values["add_integration_latency_tm70_alarm"] = add_integration_latency_tm70_alarm
        if add_integration_latency_tm90_alarm is not None:
            self._values["add_integration_latency_tm90_alarm"] = add_integration_latency_tm90_alarm
        if add_integration_latency_tm95_alarm is not None:
            self._values["add_integration_latency_tm95_alarm"] = add_integration_latency_tm95_alarm
        if add_integration_latency_tm95_outlier_alarm is not None:
            self._values["add_integration_latency_tm95_outlier_alarm"] = add_integration_latency_tm95_outlier_alarm
        if add_integration_latency_tm9999_alarm is not None:
            self._values["add_integration_latency_tm9999_alarm"] = add_integration_latency_tm9999_alarm
        if add_integration_latency_tm9999_outlier_alarm is not None:
            self._values["add_integration_latency_tm9999_outlier_alarm"] = add_integration_latency_tm9999_outlier_alarm
        if add_integration_latency_tm999_alarm is not None:
            self._values["add_integration_latency_tm999_alarm"] = add_integration_latency_tm999_alarm
        if add_integration_latency_tm999_outlier_alarm is not None:
            self._values["add_integration_latency_tm999_outlier_alarm"] = add_integration_latency_tm999_outlier_alarm
        if add_integration_latency_tm99_alarm is not None:
            self._values["add_integration_latency_tm99_alarm"] = add_integration_latency_tm99_alarm
        if add_integration_latency_tm99_outlier_alarm is not None:
            self._values["add_integration_latency_tm99_outlier_alarm"] = add_integration_latency_tm99_outlier_alarm
        if add_latency_average_alarm is not None:
            self._values["add_latency_average_alarm"] = add_latency_average_alarm
        if add_latency_p100_alarm is not None:
            self._values["add_latency_p100_alarm"] = add_latency_p100_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p70_alarm is not None:
            self._values["add_latency_p70_alarm"] = add_latency_p70_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p95_alarm is not None:
            self._values["add_latency_p95_alarm"] = add_latency_p95_alarm
        if add_latency_p9999_alarm is not None:
            self._values["add_latency_p9999_alarm"] = add_latency_p9999_alarm
        if add_latency_p999_alarm is not None:
            self._values["add_latency_p999_alarm"] = add_latency_p999_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_latency_tm50_alarm is not None:
            self._values["add_latency_tm50_alarm"] = add_latency_tm50_alarm
        if add_latency_tm70_alarm is not None:
            self._values["add_latency_tm70_alarm"] = add_latency_tm70_alarm
        if add_latency_tm90_alarm is not None:
            self._values["add_latency_tm90_alarm"] = add_latency_tm90_alarm
        if add_latency_tm95_alarm is not None:
            self._values["add_latency_tm95_alarm"] = add_latency_tm95_alarm
        if add_latency_tm95_outlier_alarm is not None:
            self._values["add_latency_tm95_outlier_alarm"] = add_latency_tm95_outlier_alarm
        if add_latency_tm9999_alarm is not None:
            self._values["add_latency_tm9999_alarm"] = add_latency_tm9999_alarm
        if add_latency_tm9999_outlier_alarm is not None:
            self._values["add_latency_tm9999_outlier_alarm"] = add_latency_tm9999_outlier_alarm
        if add_latency_tm999_alarm is not None:
            self._values["add_latency_tm999_alarm"] = add_latency_tm999_alarm
        if add_latency_tm999_outlier_alarm is not None:
            self._values["add_latency_tm999_outlier_alarm"] = add_latency_tm999_outlier_alarm
        if add_latency_tm99_alarm is not None:
            self._values["add_latency_tm99_alarm"] = add_latency_tm99_alarm
        if add_latency_tm99_outlier_alarm is not None:
            self._values["add_latency_tm99_outlier_alarm"] = add_latency_tm99_outlier_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if latency_types_to_render is not None:
            self._values["latency_types_to_render"] = latency_types_to_render

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4xx_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4xx_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5xx_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5xx_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_integration_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def latency_types_to_render(self) -> typing.Optional[typing.List[LatencyType]]:
        '''(experimental) You can specify what latency types you want to be rendered in the dashboards.

        Note: any latency type with an alarm will be also added automatically.
        If the list is undefined, default values will be shown.
        If the list is empty, only the latency types with an alarm will be shown (if any).

        :default: - p50, p90, p99 (

        :see: DefaultLatencyTypesShown)
        :stability: experimental
        '''
        result = self._values.get("latency_types_to_render")
        return typing.cast(typing.Optional[typing.List[LatencyType]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayV2MonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AppSyncMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4_xx_error_count_alarm": "add4XXErrorCountAlarm",
        "add4_xx_error_rate_alarm": "add4XXErrorRateAlarm",
        "add5_xx_fault_count_alarm": "add5XXFaultCountAlarm",
        "add5_xx_fault_rate_alarm": "add5XXFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
    },
)
class AppSyncMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7689a26c6918f8b69df1dedcc71fe7c5c9be50b5c9025475908207e6c4a827fa)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4_xx_error_count_alarm", value=add4_xx_error_count_alarm, expected_type=type_hints["add4_xx_error_count_alarm"])
            check_type(argname="argument add4_xx_error_rate_alarm", value=add4_xx_error_rate_alarm, expected_type=type_hints["add4_xx_error_rate_alarm"])
            check_type(argname="argument add5_xx_fault_count_alarm", value=add5_xx_fault_count_alarm, expected_type=type_hints["add5_xx_fault_count_alarm"])
            check_type(argname="argument add5_xx_fault_rate_alarm", value=add5_xx_fault_rate_alarm, expected_type=type_hints["add5_xx_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4_xx_error_count_alarm is not None:
            self._values["add4_xx_error_count_alarm"] = add4_xx_error_count_alarm
        if add4_xx_error_rate_alarm is not None:
            self._values["add4_xx_error_rate_alarm"] = add4_xx_error_rate_alarm
        if add5_xx_fault_count_alarm is not None:
            self._values["add5_xx_fault_count_alarm"] = add5_xx_fault_count_alarm
        if add5_xx_fault_rate_alarm is not None:
            self._values["add5_xx_fault_rate_alarm"] = add5_xx_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4_xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4_xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5_xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5_xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AppSyncMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AppSyncMonitoringProps",
    jsii_struct_bases=[AppSyncMonitoringOptions, AppSyncMetricFactoryProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4_xx_error_count_alarm": "add4XXErrorCountAlarm",
        "add4_xx_error_rate_alarm": "add4XXErrorRateAlarm",
        "add5_xx_fault_count_alarm": "add5XXFaultCountAlarm",
        "add5_xx_fault_rate_alarm": "add5XXFaultRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "api": "api",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
    },
)
class AppSyncMonitoringProps(AppSyncMonitoringOptions, AppSyncMetricFactoryProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4_xx_error_count_alarm: 
        :param add4_xx_error_rate_alarm: 
        :param add5_xx_fault_count_alarm: 
        :param add5_xx_fault_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p99_alarm: 
        :param add_low_tps_alarm: 
        :param api: (experimental) the GraphQL API to monitor.
        :param fill_tps_with_zeroes: (experimental) whether the TPS should be filled with zeroes. Default: - true
        :param rate_computation_method: (experimental) method to compute TPS. Default: - average

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d02bda64e67d06b43089dde217fd2da0d36374b94d0f777a89fed5911eed3ba0)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4_xx_error_count_alarm", value=add4_xx_error_count_alarm, expected_type=type_hints["add4_xx_error_count_alarm"])
            check_type(argname="argument add4_xx_error_rate_alarm", value=add4_xx_error_rate_alarm, expected_type=type_hints["add4_xx_error_rate_alarm"])
            check_type(argname="argument add5_xx_fault_count_alarm", value=add5_xx_fault_count_alarm, expected_type=type_hints["add5_xx_fault_count_alarm"])
            check_type(argname="argument add5_xx_fault_rate_alarm", value=add5_xx_fault_rate_alarm, expected_type=type_hints["add5_xx_fault_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4_xx_error_count_alarm is not None:
            self._values["add4_xx_error_count_alarm"] = add4_xx_error_count_alarm
        if add4_xx_error_rate_alarm is not None:
            self._values["add4_xx_error_rate_alarm"] = add4_xx_error_rate_alarm
        if add5_xx_fault_count_alarm is not None:
            self._values["add5_xx_fault_count_alarm"] = add5_xx_fault_count_alarm
        if add5_xx_fault_rate_alarm is not None:
            self._values["add5_xx_fault_rate_alarm"] = add5_xx_fault_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4_xx_error_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4_xx_error_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4_xx_error_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5_xx_fault_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5_xx_fault_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5_xx_fault_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi:
        '''(experimental) the GraphQL API to monitor.

        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_appsync_ceddda9d.IGraphqlApi, result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''(experimental) whether the TPS should be filled with zeroes.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''(experimental) method to compute TPS.

        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AppSyncMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AuroraClusterMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_max_serverless_database_capacity_alarm": "addMaxServerlessDatabaseCapacityAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class AuroraClusterMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_serverless_database_capacity_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__574338a5659b6b1412329597010110743bd814bf74c2b3dfd3e18b133cb46ae0)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_max_serverless_database_capacity_alarm", value=add_max_serverless_database_capacity_alarm, expected_type=type_hints["add_max_serverless_database_capacity_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_max_serverless_database_capacity_alarm is not None:
            self._values["add_max_serverless_database_capacity_alarm"] = add_max_serverless_database_capacity_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_max_serverless_database_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_serverless_database_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AuroraClusterMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AuroraClusterMonitoringProps",
    jsii_struct_bases=[RdsClusterMetricFactoryProps, AuroraClusterMonitoringOptions],
    name_mapping={
        "account": "account",
        "region": "region",
        "cluster": "cluster",
        "cluster_identifier": "clusterIdentifier",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add_cpu_usage_alarm": "addCpuUsageAlarm",
        "add_max_connection_count_alarm": "addMaxConnectionCountAlarm",
        "add_max_serverless_database_capacity_alarm": "addMaxServerlessDatabaseCapacityAlarm",
        "add_min_connection_count_alarm": "addMinConnectionCountAlarm",
    },
)
class AuroraClusterMonitoringProps(
    RdsClusterMetricFactoryProps,
    AuroraClusterMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
        cluster_identifier: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param cluster: (experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).
        :param cluster_identifier: (deprecated) database cluster identifier (either this or ``cluster`` need to be specified).
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add_cpu_usage_alarm: 
        :param add_max_connection_count_alarm: 
        :param add_max_serverless_database_capacity_alarm: 
        :param add_min_connection_count_alarm: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cdf794b2bdb96ec005eebaca725d331989d9e18a926022445c2c5cac7f5bff7)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
            check_type(argname="argument cluster_identifier", value=cluster_identifier, expected_type=type_hints["cluster_identifier"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add_cpu_usage_alarm", value=add_cpu_usage_alarm, expected_type=type_hints["add_cpu_usage_alarm"])
            check_type(argname="argument add_max_connection_count_alarm", value=add_max_connection_count_alarm, expected_type=type_hints["add_max_connection_count_alarm"])
            check_type(argname="argument add_max_serverless_database_capacity_alarm", value=add_max_serverless_database_capacity_alarm, expected_type=type_hints["add_max_serverless_database_capacity_alarm"])
            check_type(argname="argument add_min_connection_count_alarm", value=add_min_connection_count_alarm, expected_type=type_hints["add_min_connection_count_alarm"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if cluster is not None:
            self._values["cluster"] = cluster
        if cluster_identifier is not None:
            self._values["cluster_identifier"] = cluster_identifier
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add_cpu_usage_alarm is not None:
            self._values["add_cpu_usage_alarm"] = add_cpu_usage_alarm
        if add_max_connection_count_alarm is not None:
            self._values["add_max_connection_count_alarm"] = add_max_connection_count_alarm
        if add_max_serverless_database_capacity_alarm is not None:
            self._values["add_max_serverless_database_capacity_alarm"] = add_max_serverless_database_capacity_alarm
        if add_min_connection_count_alarm is not None:
            self._values["add_min_connection_count_alarm"] = add_min_connection_count_alarm

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cluster(
        self,
    ) -> typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]]:
        '''(experimental) database cluster (either this or ``clusterIdentifier`` need to be specified).

        :stability: experimental
        '''
        result = self._values.get("cluster")
        return typing.cast(typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]], result)

    @builtins.property
    def cluster_identifier(self) -> typing.Optional[builtins.str]:
        '''(deprecated) database cluster identifier (either this or ``cluster`` need to be specified).

        :deprecated: please use ``cluster`` instead

        :stability: deprecated
        '''
        result = self._values.get("cluster_identifier")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add_cpu_usage_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_cpu_usage_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageThreshold]], result)

    @builtins.property
    def add_max_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighConnectionCountThreshold]], result)

    @builtins.property
    def add_max_serverless_database_capacity_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, UsageCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_max_serverless_database_capacity_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, UsageCountThreshold]], result)

    @builtins.property
    def add_min_connection_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_min_connection_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowConnectionCountThreshold]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AuroraClusterMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AutoScalingGroupMonitoringOptions",
    jsii_struct_bases=[BaseMonitoringProps],
    name_mapping={
        "account": "account",
        "region": "region",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class AutoScalingGroupMonitoringOptions(BaseMonitoringProps):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e20eafd19e3c8290a8b7fca960f78f74170ec2c088028572ab8b4b1e2e060ecb)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AutoScalingGroupMonitoringOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.AutoScalingGroupMonitoringProps",
    jsii_struct_bases=[
        AutoScalingGroupMetricFactoryProps, AutoScalingGroupMonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "auto_scaling_group": "autoScalingGroup",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
    },
)
class AutoScalingGroupMonitoringProps(
    AutoScalingGroupMetricFactoryProps,
    AutoScalingGroupMonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param auto_scaling_group: 
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f05524b746e80181a5a2702bde2a12630e481e0280632cb11b164894a2dd0c6)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument auto_scaling_group", value=auto_scaling_group, expected_type=type_hints["auto_scaling_group"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "auto_scaling_group": auto_scaling_group,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_scaling_group(self) -> _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup:
        '''
        :stability: experimental
        '''
        result = self._values.get("auto_scaling_group")
        assert result is not None, "Required property 'auto_scaling_group' is missing"
        return typing.cast(_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup, result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AutoScalingGroupMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DefaultAlarmAnnotationStrategy(
    FillingAlarmAnnotationStrategy,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DefaultAlarmAnnotationStrategy",
):
    '''(experimental) Default annotation strategy that returns the built-in alarm annotation.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="createAnnotationToFill")
    def _create_annotation_to_fill(
        self,
        *,
        alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
        comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
        datapoints_to_alarm: jsii.Number,
        evaluation_periods: jsii.Number,
        fill_alarm_range: builtins.bool,
        metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
        threshold: jsii.Number,
        min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
        min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
        override_annotation_color: typing.Optional[builtins.str] = None,
        override_annotation_label: typing.Optional[builtins.str] = None,
        override_annotation_visibility: typing.Optional[builtins.bool] = None,
        action: IAlarmActionStrategy,
        custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
        custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        dedupe_string: typing.Optional[builtins.str] = None,
        disambiguator: typing.Optional[builtins.str] = None,
    ) -> _aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation:
        '''
        :param alarm: 
        :param comparison_operator: 
        :param datapoints_to_alarm: 
        :param evaluation_periods: 
        :param fill_alarm_range: 
        :param metric: 
        :param threshold: 
        :param min_metric_samples_to_alarm: 
        :param min_sample_count_to_evaluate_datapoint: 
        :param override_annotation_color: 
        :param override_annotation_label: 
        :param override_annotation_visibility: 
        :param action: 
        :param custom_params: 
        :param custom_tags: 
        :param dedupe_string: 
        :param disambiguator: 

        :stability: experimental
        '''
        props = AlarmAnnotationStrategyProps(
            alarm=alarm,
            comparison_operator=comparison_operator,
            datapoints_to_alarm=datapoints_to_alarm,
            evaluation_periods=evaluation_periods,
            fill_alarm_range=fill_alarm_range,
            metric=metric,
            threshold=threshold,
            min_metric_samples_to_alarm=min_metric_samples_to_alarm,
            min_sample_count_to_evaluate_datapoint=min_sample_count_to_evaluate_datapoint,
            override_annotation_color=override_annotation_color,
            override_annotation_label=override_annotation_label,
            override_annotation_visibility=override_annotation_visibility,
            action=action,
            custom_params=custom_params,
            custom_tags=custom_tags,
            dedupe_string=dedupe_string,
            disambiguator=disambiguator,
        )

        return typing.cast(_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, jsii.invoke(self, "createAnnotationToFill", [props]))


class DoNotModifyDedupeString(
    ExtendDedupeString,
    metaclass=jsii.JSIIMeta,
    jsii_type="cdk-monitoring-constructs.DoNotModifyDedupeString",
):
    '''(experimental) Default dedupe strategy - does not add any prefix nor suffix.

    :stability: experimental
    '''

    def __init__(
        self,
        prefix: typing.Optional[builtins.str] = None,
        suffix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param prefix: -
        :param suffix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bc62460d72cc8f1ddc60328e8cb925681469024fd4244d40c80eb4546e6e3122)
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument suffix", value=suffix, expected_type=type_hints["suffix"])
        jsii.create(self.__class__, self, [prefix, suffix])


@jsii.data_type(
    jsii_type="cdk-monitoring-constructs.ApiGatewayV2HttpApiMonitoringProps",
    jsii_struct_bases=[
        ApiGatewayV2HttpApiMetricFactoryProps, ApiGatewayV2MonitoringOptions
    ],
    name_mapping={
        "account": "account",
        "region": "region",
        "api": "api",
        "api_method": "apiMethod",
        "api_resource": "apiResource",
        "api_stage": "apiStage",
        "fill_tps_with_zeroes": "fillTpsWithZeroes",
        "rate_computation_method": "rateComputationMethod",
        "alarm_friendly_name": "alarmFriendlyName",
        "human_readable_name": "humanReadableName",
        "local_alarm_name_prefix_override": "localAlarmNamePrefixOverride",
        "add_to_alarm_dashboard": "addToAlarmDashboard",
        "add_to_detail_dashboard": "addToDetailDashboard",
        "add_to_summary_dashboard": "addToSummaryDashboard",
        "use_created_alarms": "useCreatedAlarms",
        "add4xx_count_alarm": "add4xxCountAlarm",
        "add4xx_rate_alarm": "add4xxRateAlarm",
        "add5xx_count_alarm": "add5xxCountAlarm",
        "add5xx_rate_alarm": "add5xxRateAlarm",
        "add_high_tps_alarm": "addHighTpsAlarm",
        "add_integration_latency_average_alarm": "addIntegrationLatencyAverageAlarm",
        "add_integration_latency_p100_alarm": "addIntegrationLatencyP100Alarm",
        "add_integration_latency_p50_alarm": "addIntegrationLatencyP50Alarm",
        "add_integration_latency_p70_alarm": "addIntegrationLatencyP70Alarm",
        "add_integration_latency_p90_alarm": "addIntegrationLatencyP90Alarm",
        "add_integration_latency_p95_alarm": "addIntegrationLatencyP95Alarm",
        "add_integration_latency_p9999_alarm": "addIntegrationLatencyP9999Alarm",
        "add_integration_latency_p999_alarm": "addIntegrationLatencyP999Alarm",
        "add_integration_latency_p99_alarm": "addIntegrationLatencyP99Alarm",
        "add_integration_latency_tm50_alarm": "addIntegrationLatencyTM50Alarm",
        "add_integration_latency_tm70_alarm": "addIntegrationLatencyTM70Alarm",
        "add_integration_latency_tm90_alarm": "addIntegrationLatencyTM90Alarm",
        "add_integration_latency_tm95_alarm": "addIntegrationLatencyTM95Alarm",
        "add_integration_latency_tm95_outlier_alarm": "addIntegrationLatencyTM95OutlierAlarm",
        "add_integration_latency_tm9999_alarm": "addIntegrationLatencyTM9999Alarm",
        "add_integration_latency_tm9999_outlier_alarm": "addIntegrationLatencyTM9999OutlierAlarm",
        "add_integration_latency_tm999_alarm": "addIntegrationLatencyTM999Alarm",
        "add_integration_latency_tm999_outlier_alarm": "addIntegrationLatencyTM999OutlierAlarm",
        "add_integration_latency_tm99_alarm": "addIntegrationLatencyTM99Alarm",
        "add_integration_latency_tm99_outlier_alarm": "addIntegrationLatencyTM99OutlierAlarm",
        "add_latency_average_alarm": "addLatencyAverageAlarm",
        "add_latency_p100_alarm": "addLatencyP100Alarm",
        "add_latency_p50_alarm": "addLatencyP50Alarm",
        "add_latency_p70_alarm": "addLatencyP70Alarm",
        "add_latency_p90_alarm": "addLatencyP90Alarm",
        "add_latency_p95_alarm": "addLatencyP95Alarm",
        "add_latency_p9999_alarm": "addLatencyP9999Alarm",
        "add_latency_p999_alarm": "addLatencyP999Alarm",
        "add_latency_p99_alarm": "addLatencyP99Alarm",
        "add_latency_tm50_alarm": "addLatencyTM50Alarm",
        "add_latency_tm70_alarm": "addLatencyTM70Alarm",
        "add_latency_tm90_alarm": "addLatencyTM90Alarm",
        "add_latency_tm95_alarm": "addLatencyTM95Alarm",
        "add_latency_tm95_outlier_alarm": "addLatencyTM95OutlierAlarm",
        "add_latency_tm9999_alarm": "addLatencyTM9999Alarm",
        "add_latency_tm9999_outlier_alarm": "addLatencyTM9999OutlierAlarm",
        "add_latency_tm999_alarm": "addLatencyTM999Alarm",
        "add_latency_tm999_outlier_alarm": "addLatencyTM999OutlierAlarm",
        "add_latency_tm99_alarm": "addLatencyTM99Alarm",
        "add_latency_tm99_outlier_alarm": "addLatencyTM99OutlierAlarm",
        "add_low_tps_alarm": "addLowTpsAlarm",
        "latency_types_to_render": "latencyTypesToRender",
    },
)
class ApiGatewayV2HttpApiMonitoringProps(
    ApiGatewayV2HttpApiMetricFactoryProps,
    ApiGatewayV2MonitoringOptions,
):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
        api_method: typing.Optional[builtins.str] = None,
        api_resource: typing.Optional[builtins.str] = None,
        api_stage: typing.Optional[builtins.str] = None,
        fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
        rate_computation_method: typing.Optional[RateComputationMethod] = None,
        alarm_friendly_name: typing.Optional[builtins.str] = None,
        human_readable_name: typing.Optional[builtins.str] = None,
        local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
        add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
        add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
        add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
        use_created_alarms: typing.Optional[IAlarmConsumer] = None,
        add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
        latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    ) -> None:
        '''
        :param account: (experimental) Account where the metrics exist. Default: The account configured by the construct holding the Monitoring construct
        :param region: (experimental) Region where the metrics exist. Default: The region configured by the construct holding the Monitoring construct
        :param api: 
        :param api_method: (experimental) On undefined value is not set in dimensions.
        :param api_resource: (experimental) On undefined value is not set in dimensions.
        :param api_stage: Default: - $default
        :param fill_tps_with_zeroes: Default: - true
        :param rate_computation_method: Default: - average
        :param alarm_friendly_name: (experimental) Plain name, used in naming alarms. This unique among other resources, and respect the AWS CDK restriction posed on alarm names. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens. Default: - derives name from the construct itself
        :param human_readable_name: (experimental) Human-readable name is a freeform string, used as a caption or description. There are no limitations on what it can be. Default: - use alarmFriendlyName
        :param local_alarm_name_prefix_override: (experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value. The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.
        :param add_to_alarm_dashboard: (experimental) Flag indicating if the widgets should be added to alarm dashboard. Default: - true
        :param add_to_detail_dashboard: (experimental) Flag indicating if the widgets should be added to detailed dashboard. Default: - true
        :param add_to_summary_dashboard: (experimental) Flag indicating if the widgets should be added to summary dashboard. Default: - true
        :param use_created_alarms: (experimental) Calls provided function to process all alarms created.
        :param add4xx_count_alarm: 
        :param add4xx_rate_alarm: 
        :param add5xx_count_alarm: 
        :param add5xx_rate_alarm: 
        :param add_high_tps_alarm: 
        :param add_integration_latency_average_alarm: 
        :param add_integration_latency_p100_alarm: 
        :param add_integration_latency_p50_alarm: 
        :param add_integration_latency_p70_alarm: 
        :param add_integration_latency_p90_alarm: 
        :param add_integration_latency_p95_alarm: 
        :param add_integration_latency_p9999_alarm: 
        :param add_integration_latency_p999_alarm: 
        :param add_integration_latency_p99_alarm: 
        :param add_integration_latency_tm50_alarm: 
        :param add_integration_latency_tm70_alarm: 
        :param add_integration_latency_tm90_alarm: 
        :param add_integration_latency_tm95_alarm: 
        :param add_integration_latency_tm95_outlier_alarm: 
        :param add_integration_latency_tm9999_alarm: 
        :param add_integration_latency_tm9999_outlier_alarm: 
        :param add_integration_latency_tm999_alarm: 
        :param add_integration_latency_tm999_outlier_alarm: 
        :param add_integration_latency_tm99_alarm: 
        :param add_integration_latency_tm99_outlier_alarm: 
        :param add_latency_average_alarm: 
        :param add_latency_p100_alarm: 
        :param add_latency_p50_alarm: 
        :param add_latency_p70_alarm: 
        :param add_latency_p90_alarm: 
        :param add_latency_p95_alarm: 
        :param add_latency_p9999_alarm: 
        :param add_latency_p999_alarm: 
        :param add_latency_p99_alarm: 
        :param add_latency_tm50_alarm: 
        :param add_latency_tm70_alarm: 
        :param add_latency_tm90_alarm: 
        :param add_latency_tm95_alarm: 
        :param add_latency_tm95_outlier_alarm: 
        :param add_latency_tm9999_alarm: 
        :param add_latency_tm9999_outlier_alarm: 
        :param add_latency_tm999_alarm: 
        :param add_latency_tm999_outlier_alarm: 
        :param add_latency_tm99_alarm: 
        :param add_latency_tm99_outlier_alarm: 
        :param add_low_tps_alarm: 
        :param latency_types_to_render: (experimental) You can specify what latency types you want to be rendered in the dashboards. Note: any latency type with an alarm will be also added automatically. If the list is undefined, default values will be shown. If the list is empty, only the latency types with an alarm will be shown (if any). Default: - p50, p90, p99 (

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc3f94d08743043a08e42c28745bc42883e044246b024761b9bd90d15e7bbe1c)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument api", value=api, expected_type=type_hints["api"])
            check_type(argname="argument api_method", value=api_method, expected_type=type_hints["api_method"])
            check_type(argname="argument api_resource", value=api_resource, expected_type=type_hints["api_resource"])
            check_type(argname="argument api_stage", value=api_stage, expected_type=type_hints["api_stage"])
            check_type(argname="argument fill_tps_with_zeroes", value=fill_tps_with_zeroes, expected_type=type_hints["fill_tps_with_zeroes"])
            check_type(argname="argument rate_computation_method", value=rate_computation_method, expected_type=type_hints["rate_computation_method"])
            check_type(argname="argument alarm_friendly_name", value=alarm_friendly_name, expected_type=type_hints["alarm_friendly_name"])
            check_type(argname="argument human_readable_name", value=human_readable_name, expected_type=type_hints["human_readable_name"])
            check_type(argname="argument local_alarm_name_prefix_override", value=local_alarm_name_prefix_override, expected_type=type_hints["local_alarm_name_prefix_override"])
            check_type(argname="argument add_to_alarm_dashboard", value=add_to_alarm_dashboard, expected_type=type_hints["add_to_alarm_dashboard"])
            check_type(argname="argument add_to_detail_dashboard", value=add_to_detail_dashboard, expected_type=type_hints["add_to_detail_dashboard"])
            check_type(argname="argument add_to_summary_dashboard", value=add_to_summary_dashboard, expected_type=type_hints["add_to_summary_dashboard"])
            check_type(argname="argument use_created_alarms", value=use_created_alarms, expected_type=type_hints["use_created_alarms"])
            check_type(argname="argument add4xx_count_alarm", value=add4xx_count_alarm, expected_type=type_hints["add4xx_count_alarm"])
            check_type(argname="argument add4xx_rate_alarm", value=add4xx_rate_alarm, expected_type=type_hints["add4xx_rate_alarm"])
            check_type(argname="argument add5xx_count_alarm", value=add5xx_count_alarm, expected_type=type_hints["add5xx_count_alarm"])
            check_type(argname="argument add5xx_rate_alarm", value=add5xx_rate_alarm, expected_type=type_hints["add5xx_rate_alarm"])
            check_type(argname="argument add_high_tps_alarm", value=add_high_tps_alarm, expected_type=type_hints["add_high_tps_alarm"])
            check_type(argname="argument add_integration_latency_average_alarm", value=add_integration_latency_average_alarm, expected_type=type_hints["add_integration_latency_average_alarm"])
            check_type(argname="argument add_integration_latency_p100_alarm", value=add_integration_latency_p100_alarm, expected_type=type_hints["add_integration_latency_p100_alarm"])
            check_type(argname="argument add_integration_latency_p50_alarm", value=add_integration_latency_p50_alarm, expected_type=type_hints["add_integration_latency_p50_alarm"])
            check_type(argname="argument add_integration_latency_p70_alarm", value=add_integration_latency_p70_alarm, expected_type=type_hints["add_integration_latency_p70_alarm"])
            check_type(argname="argument add_integration_latency_p90_alarm", value=add_integration_latency_p90_alarm, expected_type=type_hints["add_integration_latency_p90_alarm"])
            check_type(argname="argument add_integration_latency_p95_alarm", value=add_integration_latency_p95_alarm, expected_type=type_hints["add_integration_latency_p95_alarm"])
            check_type(argname="argument add_integration_latency_p9999_alarm", value=add_integration_latency_p9999_alarm, expected_type=type_hints["add_integration_latency_p9999_alarm"])
            check_type(argname="argument add_integration_latency_p999_alarm", value=add_integration_latency_p999_alarm, expected_type=type_hints["add_integration_latency_p999_alarm"])
            check_type(argname="argument add_integration_latency_p99_alarm", value=add_integration_latency_p99_alarm, expected_type=type_hints["add_integration_latency_p99_alarm"])
            check_type(argname="argument add_integration_latency_tm50_alarm", value=add_integration_latency_tm50_alarm, expected_type=type_hints["add_integration_latency_tm50_alarm"])
            check_type(argname="argument add_integration_latency_tm70_alarm", value=add_integration_latency_tm70_alarm, expected_type=type_hints["add_integration_latency_tm70_alarm"])
            check_type(argname="argument add_integration_latency_tm90_alarm", value=add_integration_latency_tm90_alarm, expected_type=type_hints["add_integration_latency_tm90_alarm"])
            check_type(argname="argument add_integration_latency_tm95_alarm", value=add_integration_latency_tm95_alarm, expected_type=type_hints["add_integration_latency_tm95_alarm"])
            check_type(argname="argument add_integration_latency_tm95_outlier_alarm", value=add_integration_latency_tm95_outlier_alarm, expected_type=type_hints["add_integration_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm9999_alarm", value=add_integration_latency_tm9999_alarm, expected_type=type_hints["add_integration_latency_tm9999_alarm"])
            check_type(argname="argument add_integration_latency_tm9999_outlier_alarm", value=add_integration_latency_tm9999_outlier_alarm, expected_type=type_hints["add_integration_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm999_alarm", value=add_integration_latency_tm999_alarm, expected_type=type_hints["add_integration_latency_tm999_alarm"])
            check_type(argname="argument add_integration_latency_tm999_outlier_alarm", value=add_integration_latency_tm999_outlier_alarm, expected_type=type_hints["add_integration_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_integration_latency_tm99_alarm", value=add_integration_latency_tm99_alarm, expected_type=type_hints["add_integration_latency_tm99_alarm"])
            check_type(argname="argument add_integration_latency_tm99_outlier_alarm", value=add_integration_latency_tm99_outlier_alarm, expected_type=type_hints["add_integration_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_latency_average_alarm", value=add_latency_average_alarm, expected_type=type_hints["add_latency_average_alarm"])
            check_type(argname="argument add_latency_p100_alarm", value=add_latency_p100_alarm, expected_type=type_hints["add_latency_p100_alarm"])
            check_type(argname="argument add_latency_p50_alarm", value=add_latency_p50_alarm, expected_type=type_hints["add_latency_p50_alarm"])
            check_type(argname="argument add_latency_p70_alarm", value=add_latency_p70_alarm, expected_type=type_hints["add_latency_p70_alarm"])
            check_type(argname="argument add_latency_p90_alarm", value=add_latency_p90_alarm, expected_type=type_hints["add_latency_p90_alarm"])
            check_type(argname="argument add_latency_p95_alarm", value=add_latency_p95_alarm, expected_type=type_hints["add_latency_p95_alarm"])
            check_type(argname="argument add_latency_p9999_alarm", value=add_latency_p9999_alarm, expected_type=type_hints["add_latency_p9999_alarm"])
            check_type(argname="argument add_latency_p999_alarm", value=add_latency_p999_alarm, expected_type=type_hints["add_latency_p999_alarm"])
            check_type(argname="argument add_latency_p99_alarm", value=add_latency_p99_alarm, expected_type=type_hints["add_latency_p99_alarm"])
            check_type(argname="argument add_latency_tm50_alarm", value=add_latency_tm50_alarm, expected_type=type_hints["add_latency_tm50_alarm"])
            check_type(argname="argument add_latency_tm70_alarm", value=add_latency_tm70_alarm, expected_type=type_hints["add_latency_tm70_alarm"])
            check_type(argname="argument add_latency_tm90_alarm", value=add_latency_tm90_alarm, expected_type=type_hints["add_latency_tm90_alarm"])
            check_type(argname="argument add_latency_tm95_alarm", value=add_latency_tm95_alarm, expected_type=type_hints["add_latency_tm95_alarm"])
            check_type(argname="argument add_latency_tm95_outlier_alarm", value=add_latency_tm95_outlier_alarm, expected_type=type_hints["add_latency_tm95_outlier_alarm"])
            check_type(argname="argument add_latency_tm9999_alarm", value=add_latency_tm9999_alarm, expected_type=type_hints["add_latency_tm9999_alarm"])
            check_type(argname="argument add_latency_tm9999_outlier_alarm", value=add_latency_tm9999_outlier_alarm, expected_type=type_hints["add_latency_tm9999_outlier_alarm"])
            check_type(argname="argument add_latency_tm999_alarm", value=add_latency_tm999_alarm, expected_type=type_hints["add_latency_tm999_alarm"])
            check_type(argname="argument add_latency_tm999_outlier_alarm", value=add_latency_tm999_outlier_alarm, expected_type=type_hints["add_latency_tm999_outlier_alarm"])
            check_type(argname="argument add_latency_tm99_alarm", value=add_latency_tm99_alarm, expected_type=type_hints["add_latency_tm99_alarm"])
            check_type(argname="argument add_latency_tm99_outlier_alarm", value=add_latency_tm99_outlier_alarm, expected_type=type_hints["add_latency_tm99_outlier_alarm"])
            check_type(argname="argument add_low_tps_alarm", value=add_low_tps_alarm, expected_type=type_hints["add_low_tps_alarm"])
            check_type(argname="argument latency_types_to_render", value=latency_types_to_render, expected_type=type_hints["latency_types_to_render"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "api": api,
        }
        if account is not None:
            self._values["account"] = account
        if region is not None:
            self._values["region"] = region
        if api_method is not None:
            self._values["api_method"] = api_method
        if api_resource is not None:
            self._values["api_resource"] = api_resource
        if api_stage is not None:
            self._values["api_stage"] = api_stage
        if fill_tps_with_zeroes is not None:
            self._values["fill_tps_with_zeroes"] = fill_tps_with_zeroes
        if rate_computation_method is not None:
            self._values["rate_computation_method"] = rate_computation_method
        if alarm_friendly_name is not None:
            self._values["alarm_friendly_name"] = alarm_friendly_name
        if human_readable_name is not None:
            self._values["human_readable_name"] = human_readable_name
        if local_alarm_name_prefix_override is not None:
            self._values["local_alarm_name_prefix_override"] = local_alarm_name_prefix_override
        if add_to_alarm_dashboard is not None:
            self._values["add_to_alarm_dashboard"] = add_to_alarm_dashboard
        if add_to_detail_dashboard is not None:
            self._values["add_to_detail_dashboard"] = add_to_detail_dashboard
        if add_to_summary_dashboard is not None:
            self._values["add_to_summary_dashboard"] = add_to_summary_dashboard
        if use_created_alarms is not None:
            self._values["use_created_alarms"] = use_created_alarms
        if add4xx_count_alarm is not None:
            self._values["add4xx_count_alarm"] = add4xx_count_alarm
        if add4xx_rate_alarm is not None:
            self._values["add4xx_rate_alarm"] = add4xx_rate_alarm
        if add5xx_count_alarm is not None:
            self._values["add5xx_count_alarm"] = add5xx_count_alarm
        if add5xx_rate_alarm is not None:
            self._values["add5xx_rate_alarm"] = add5xx_rate_alarm
        if add_high_tps_alarm is not None:
            self._values["add_high_tps_alarm"] = add_high_tps_alarm
        if add_integration_latency_average_alarm is not None:
            self._values["add_integration_latency_average_alarm"] = add_integration_latency_average_alarm
        if add_integration_latency_p100_alarm is not None:
            self._values["add_integration_latency_p100_alarm"] = add_integration_latency_p100_alarm
        if add_integration_latency_p50_alarm is not None:
            self._values["add_integration_latency_p50_alarm"] = add_integration_latency_p50_alarm
        if add_integration_latency_p70_alarm is not None:
            self._values["add_integration_latency_p70_alarm"] = add_integration_latency_p70_alarm
        if add_integration_latency_p90_alarm is not None:
            self._values["add_integration_latency_p90_alarm"] = add_integration_latency_p90_alarm
        if add_integration_latency_p95_alarm is not None:
            self._values["add_integration_latency_p95_alarm"] = add_integration_latency_p95_alarm
        if add_integration_latency_p9999_alarm is not None:
            self._values["add_integration_latency_p9999_alarm"] = add_integration_latency_p9999_alarm
        if add_integration_latency_p999_alarm is not None:
            self._values["add_integration_latency_p999_alarm"] = add_integration_latency_p999_alarm
        if add_integration_latency_p99_alarm is not None:
            self._values["add_integration_latency_p99_alarm"] = add_integration_latency_p99_alarm
        if add_integration_latency_tm50_alarm is not None:
            self._values["add_integration_latency_tm50_alarm"] = add_integration_latency_tm50_alarm
        if add_integration_latency_tm70_alarm is not None:
            self._values["add_integration_latency_tm70_alarm"] = add_integration_latency_tm70_alarm
        if add_integration_latency_tm90_alarm is not None:
            self._values["add_integration_latency_tm90_alarm"] = add_integration_latency_tm90_alarm
        if add_integration_latency_tm95_alarm is not None:
            self._values["add_integration_latency_tm95_alarm"] = add_integration_latency_tm95_alarm
        if add_integration_latency_tm95_outlier_alarm is not None:
            self._values["add_integration_latency_tm95_outlier_alarm"] = add_integration_latency_tm95_outlier_alarm
        if add_integration_latency_tm9999_alarm is not None:
            self._values["add_integration_latency_tm9999_alarm"] = add_integration_latency_tm9999_alarm
        if add_integration_latency_tm9999_outlier_alarm is not None:
            self._values["add_integration_latency_tm9999_outlier_alarm"] = add_integration_latency_tm9999_outlier_alarm
        if add_integration_latency_tm999_alarm is not None:
            self._values["add_integration_latency_tm999_alarm"] = add_integration_latency_tm999_alarm
        if add_integration_latency_tm999_outlier_alarm is not None:
            self._values["add_integration_latency_tm999_outlier_alarm"] = add_integration_latency_tm999_outlier_alarm
        if add_integration_latency_tm99_alarm is not None:
            self._values["add_integration_latency_tm99_alarm"] = add_integration_latency_tm99_alarm
        if add_integration_latency_tm99_outlier_alarm is not None:
            self._values["add_integration_latency_tm99_outlier_alarm"] = add_integration_latency_tm99_outlier_alarm
        if add_latency_average_alarm is not None:
            self._values["add_latency_average_alarm"] = add_latency_average_alarm
        if add_latency_p100_alarm is not None:
            self._values["add_latency_p100_alarm"] = add_latency_p100_alarm
        if add_latency_p50_alarm is not None:
            self._values["add_latency_p50_alarm"] = add_latency_p50_alarm
        if add_latency_p70_alarm is not None:
            self._values["add_latency_p70_alarm"] = add_latency_p70_alarm
        if add_latency_p90_alarm is not None:
            self._values["add_latency_p90_alarm"] = add_latency_p90_alarm
        if add_latency_p95_alarm is not None:
            self._values["add_latency_p95_alarm"] = add_latency_p95_alarm
        if add_latency_p9999_alarm is not None:
            self._values["add_latency_p9999_alarm"] = add_latency_p9999_alarm
        if add_latency_p999_alarm is not None:
            self._values["add_latency_p999_alarm"] = add_latency_p999_alarm
        if add_latency_p99_alarm is not None:
            self._values["add_latency_p99_alarm"] = add_latency_p99_alarm
        if add_latency_tm50_alarm is not None:
            self._values["add_latency_tm50_alarm"] = add_latency_tm50_alarm
        if add_latency_tm70_alarm is not None:
            self._values["add_latency_tm70_alarm"] = add_latency_tm70_alarm
        if add_latency_tm90_alarm is not None:
            self._values["add_latency_tm90_alarm"] = add_latency_tm90_alarm
        if add_latency_tm95_alarm is not None:
            self._values["add_latency_tm95_alarm"] = add_latency_tm95_alarm
        if add_latency_tm95_outlier_alarm is not None:
            self._values["add_latency_tm95_outlier_alarm"] = add_latency_tm95_outlier_alarm
        if add_latency_tm9999_alarm is not None:
            self._values["add_latency_tm9999_alarm"] = add_latency_tm9999_alarm
        if add_latency_tm9999_outlier_alarm is not None:
            self._values["add_latency_tm9999_outlier_alarm"] = add_latency_tm9999_outlier_alarm
        if add_latency_tm999_alarm is not None:
            self._values["add_latency_tm999_alarm"] = add_latency_tm999_alarm
        if add_latency_tm999_outlier_alarm is not None:
            self._values["add_latency_tm999_outlier_alarm"] = add_latency_tm999_outlier_alarm
        if add_latency_tm99_alarm is not None:
            self._values["add_latency_tm99_alarm"] = add_latency_tm99_alarm
        if add_latency_tm99_outlier_alarm is not None:
            self._values["add_latency_tm99_outlier_alarm"] = add_latency_tm99_outlier_alarm
        if add_low_tps_alarm is not None:
            self._values["add_low_tps_alarm"] = add_low_tps_alarm
        if latency_types_to_render is not None:
            self._values["latency_types_to_render"] = latency_types_to_render

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''(experimental) Account where the metrics exist.

        :default: The account configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) Region where the metrics exist.

        :default: The region configured by the construct holding the Monitoring construct

        :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html
        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api(self) -> _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi:
        '''
        :stability: experimental
        '''
        result = self._values.get("api")
        assert result is not None, "Required property 'api' is missing"
        return typing.cast(_aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi, result)

    @builtins.property
    def api_method(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_method")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_resource(self) -> typing.Optional[builtins.str]:
        '''(experimental) On undefined value is not set in dimensions.

        :stability: experimental
        '''
        result = self._values.get("api_resource")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def api_stage(self) -> typing.Optional[builtins.str]:
        '''
        :default: - $default

        :stability: experimental
        '''
        result = self._values.get("api_stage")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fill_tps_with_zeroes(self) -> typing.Optional[builtins.bool]:
        '''
        :default: - true

        :stability: experimental
        '''
        result = self._values.get("fill_tps_with_zeroes")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def rate_computation_method(self) -> typing.Optional[RateComputationMethod]:
        '''
        :default: - average

        :stability: experimental
        '''
        result = self._values.get("rate_computation_method")
        return typing.cast(typing.Optional[RateComputationMethod], result)

    @builtins.property
    def alarm_friendly_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Plain name, used in naming alarms.

        This unique among other resources, and respect the AWS CDK restriction posed on alarm names.
        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :default: - derives name from the construct itself

        :stability: experimental
        '''
        result = self._values.get("alarm_friendly_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def human_readable_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Human-readable name is a freeform string, used as a caption or description.

        There are no limitations on what it can be.

        :default: - use alarmFriendlyName

        :stability: experimental
        '''
        result = self._values.get("human_readable_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_alarm_name_prefix_override(self) -> typing.Optional[builtins.str]:
        '''(experimental) If this is defined, the local alarm name prefix used in naming alarms for the construct will be set to this value.

        The length must be 1 - 255 characters and although the validation rules are undocumented, we recommend using ASCII and hyphens.

        :see: AlarmNamingStrategy for more details on alarm name prefixes
        :stability: experimental
        '''
        result = self._values.get("local_alarm_name_prefix_override")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def add_to_alarm_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to alarm dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_alarm_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_detail_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to detailed dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_detail_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def add_to_summary_dashboard(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Flag indicating if the widgets should be added to summary dashboard.

        :default: - true

        :stability: experimental
        '''
        result = self._values.get("add_to_summary_dashboard")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def use_created_alarms(self) -> typing.Optional[IAlarmConsumer]:
        '''(experimental) Calls provided function to process all alarms created.

        :stability: experimental
        '''
        result = self._values.get("use_created_alarms")
        return typing.cast(typing.Optional[IAlarmConsumer], result)

    @builtins.property
    def add4xx_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add4xx_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add4xx_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add5xx_count_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_count_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorCountThreshold]], result)

    @builtins.property
    def add5xx_rate_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add5xx_rate_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ErrorRateThreshold]], result)

    @builtins.property
    def add_high_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_high_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, HighTpsThreshold]], result)

    @builtins.property
    def add_integration_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_integration_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_integration_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_average_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_average_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p100_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p100_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_p99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_p99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm50_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm50_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm70_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm70_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm90_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm90_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm95_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm95_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm9999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm9999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm999_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm999_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_latency_tm99_outlier_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_latency_tm99_outlier_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LatencyThreshold]], result)

    @builtins.property
    def add_low_tps_alarm(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("add_low_tps_alarm")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, LowTpsThreshold]], result)

    @builtins.property
    def latency_types_to_render(self) -> typing.Optional[typing.List[LatencyType]]:
        '''(experimental) You can specify what latency types you want to be rendered in the dashboards.

        Note: any latency type with an alarm will be also added automatically.
        If the list is undefined, default values will be shown.
        If the list is empty, only the latency types with an alarm will be shown (if any).

        :default: - p50, p90, p99 (

        :see: DefaultLatencyTypesShown)
        :stability: experimental
        '''
        result = self._values.get("latency_types_to_render")
        return typing.cast(typing.Optional[typing.List[LatencyType]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApiGatewayV2HttpApiMonitoringProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


__all__ = [
    "AddAlarmProps",
    "AddCompositeAlarmProps",
    "AgeAlarmFactory",
    "AlarmActionStrategyProps",
    "AlarmAnnotationStrategyProps",
    "AlarmFactory",
    "AlarmFactoryDefaults",
    "AlarmFactoryProps",
    "AlarmMatrixWidget",
    "AlarmMatrixWidgetProps",
    "AlarmMetadata",
    "AlarmNamingInput",
    "AlarmNamingStrategy",
    "AlarmSummaryMatrixWidget",
    "AlarmSummaryMatrixWidgetPropertiesJson",
    "AlarmSummaryMatrixWidgetProps",
    "AlarmWithAnnotation",
    "AnomalyDetectingAlarmFactory",
    "AnomalyDetectionMathExpression",
    "AnomalyDetectionThreshold",
    "ApiGatewayMetricFactory",
    "ApiGatewayMetricFactoryProps",
    "ApiGatewayMonitoring",
    "ApiGatewayMonitoringOptions",
    "ApiGatewayMonitoringProps",
    "ApiGatewayV2HttpApiMetricFactory",
    "ApiGatewayV2HttpApiMetricFactoryProps",
    "ApiGatewayV2HttpApiMonitoring",
    "ApiGatewayV2HttpApiMonitoringProps",
    "ApiGatewayV2MonitoringOptions",
    "AppSyncMetricFactory",
    "AppSyncMetricFactoryProps",
    "AppSyncMonitoring",
    "AppSyncMonitoringOptions",
    "AppSyncMonitoringProps",
    "ApplicationLoadBalancerMetricFactory",
    "ApplicationLoadBalancerMetricFactoryProps",
    "AuroraAlarmFactory",
    "AuroraClusterMonitoring",
    "AuroraClusterMonitoringOptions",
    "AuroraClusterMonitoringProps",
    "AutoScalingGroupMetricFactory",
    "AutoScalingGroupMetricFactoryProps",
    "AutoScalingGroupMonitoring",
    "AutoScalingGroupMonitoringOptions",
    "AutoScalingGroupMonitoringProps",
    "AvailabilityThreshold",
    "AwsConsoleUrlFactory",
    "AwsConsoleUrlFactoryProps",
    "AxisPosition",
    "BaseDlqAlarms",
    "BaseEc2ServiceAlarms",
    "BaseFargateServiceAlarms",
    "BaseLoadBalancerMetricFactoryProps",
    "BaseMetricFactory",
    "BaseMetricFactoryProps",
    "BaseMonitoringProps",
    "BaseServiceMetricFactory",
    "BaseServiceMetricFactoryProps",
    "BaseSqsQueueAlarms",
    "BillingMetricFactory",
    "BillingMonitoring",
    "BillingMonitoringOptions",
    "BillingMonitoringProps",
    "BitmapDashboard",
    "BitmapWidgetRenderingSupport",
    "CapacityType",
    "CertificateManagerMetricFactory",
    "CertificateManagerMetricFactoryProps",
    "CertificateManagerMonitoring",
    "CertificateManagerMonitoringOptions",
    "CertificateManagerMonitoringProps",
    "ChangeInSecretCountThreshold",
    "CloudFrontDistributionMetricFactory",
    "CloudFrontDistributionMetricFactoryProps",
    "CloudFrontDistributionMonitoring",
    "CloudFrontDistributionMonitoringOptions",
    "CloudFrontDistributionMonitoringProps",
    "CloudWatchLogsMetricFactory",
    "CloudWatchLogsMetricFactoryProps",
    "CodeBuildProjectMetricFactory",
    "CodeBuildProjectMetricFactoryProps",
    "CodeBuildProjectMonitoring",
    "CodeBuildProjectMonitoringOptions",
    "CodeBuildProjectMonitoringProps",
    "CompositeAlarmOperator",
    "CompositeMetricAdjuster",
    "ConnectionAlarmFactory",
    "ConsumedCapacityThreshold",
    "CustomAlarmFactory",
    "CustomAlarmThreshold",
    "CustomEc2ServiceMonitoringProps",
    "CustomFargateServiceMonitoringProps",
    "CustomMetricGroup",
    "CustomMetricGroupWithAnnotations",
    "CustomMetricSearch",
    "CustomMetricWithAlarm",
    "CustomMetricWithAnomalyDetection",
    "CustomMonitoring",
    "CustomMonitoringProps",
    "CustomThreshold",
    "CustomWidget",
    "CustomWidgetProps",
    "DashboardRenderingPreference",
    "DashboardWithBitmapCopy",
    "DaysSinceUpdateThreshold",
    "DaysToExpiryThreshold",
    "DefaultAlarmAnnotationStrategy",
    "DefaultDashboardFactory",
    "DefaultDashboards",
    "DefaultMetricAdjuster",
    "DefaultWidgetFactory",
    "DoNotModifyDedupeString",
    "DocumentDbMetricFactory",
    "DocumentDbMetricFactoryProps",
    "DocumentDbMonitoring",
    "DocumentDbMonitoringOptions",
    "DocumentDbMonitoringProps",
    "DoubleAxisGraphWidget",
    "DoubleAxisGraphWidgetProps",
    "DurationThreshold",
    "DynamicDashboardConfiguration",
    "DynamicDashboardFactory",
    "DynamoAlarmFactory",
    "DynamoTableGlobalSecondaryIndexMetricFactory",
    "DynamoTableGlobalSecondaryIndexMetricFactoryProps",
    "DynamoTableGlobalSecondaryIndexMonitoring",
    "DynamoTableGlobalSecondaryIndexMonitoringProps",
    "DynamoTableMetricFactory",
    "DynamoTableMetricFactoryProps",
    "DynamoTableMonitoring",
    "DynamoTableMonitoringOptions",
    "DynamoTableMonitoringProps",
    "EC2MetricFactory",
    "EC2MetricFactoryProps",
    "EC2Monitoring",
    "EC2MonitoringOptions",
    "EC2MonitoringProps",
    "Ec2ApplicationLoadBalancerMonitoringProps",
    "Ec2NetworkLoadBalancerMonitoringProps",
    "Ec2ServiceMonitoring",
    "Ec2ServiceMonitoringProps",
    "ElastiCacheAlarmFactory",
    "ElastiCacheClusterMetricFactory",
    "ElastiCacheClusterMetricFactoryProps",
    "ElastiCacheClusterMonitoring",
    "ElastiCacheClusterMonitoringOptions",
    "ElastiCacheClusterMonitoringProps",
    "ElastiCacheClusterType",
    "ElasticsearchClusterStatus",
    "ErrorAlarmFactory",
    "ErrorCountThreshold",
    "ErrorRateThreshold",
    "ErrorType",
    "ExtendDedupeString",
    "FargateApplicationLoadBalancerMonitoringProps",
    "FargateNetworkLoadBalancerMonitoringProps",
    "FargateServiceMonitoring",
    "FargateServiceMonitoringProps",
    "FillingAlarmAnnotationStrategy",
    "FirehoseStreamLimitThreshold",
    "FluentBitFilterMetricTag",
    "FluentBitInputMetricTag",
    "FluentBitMetricFactory",
    "FluentBitMetricFactoryProps",
    "FluentBitMetricsWithoutWidget",
    "FluentBitMonitoring",
    "FluentBitMonitoringProps",
    "FluentBitOutputMetricTag",
    "FluentBitStorageMetricTag",
    "FullRestartCountThreshold",
    "GlueJobMetricFactory",
    "GlueJobMetricFactoryProps",
    "GlueJobMonitoring",
    "GlueJobMonitoringOptions",
    "GlueJobMonitoringProps",
    "GraphWidgetType",
    "HeaderLevel",
    "HeaderWidget",
    "HealthyTaskCountThreshold",
    "HealthyTaskPercentThreshold",
    "HighConnectionCountThreshold",
    "HighMessagesPublishedThreshold",
    "HighServerlessDatabaseCapacityThreshold",
    "HighTpsThreshold",
    "IAlarmActionStrategy",
    "IAlarmAnnotationStrategy",
    "IAlarmConsumer",
    "IAlarmDedupeStringProcessor",
    "IAlarmNamingStrategy",
    "IDashboardFactory",
    "IDashboardFactoryProps",
    "IDashboardSegment",
    "IDynamicDashboardFactory",
    "IDynamicDashboardSegment",
    "IEC2MetricFactoryStrategy",
    "ILoadBalancerMetricFactory",
    "IMetricAdjuster",
    "IPublisherConsumer",
    "IWidgetFactory",
    "KeyValueTableWidget",
    "KinesisAlarmFactory",
    "KinesisDataAnalyticsAlarmFactory",
    "KinesisDataAnalyticsMetricFactory",
    "KinesisDataAnalyticsMetricFactoryProps",
    "KinesisDataAnalyticsMonitoring",
    "KinesisDataAnalyticsMonitoringOptions",
    "KinesisDataAnalyticsMonitoringProps",
    "KinesisDataStreamMetricFactory",
    "KinesisDataStreamMetricFactoryProps",
    "KinesisDataStreamMonitoring",
    "KinesisDataStreamMonitoringOptions",
    "KinesisDataStreamMonitoringProps",
    "KinesisFirehoseMetricFactory",
    "KinesisFirehoseMetricFactoryProps",
    "KinesisFirehoseMonitoring",
    "KinesisFirehoseMonitoringOptions",
    "KinesisFirehoseMonitoringProps",
    "LambdaFunctionEnhancedMetricFactory",
    "LambdaFunctionEnhancedMetricFactoryProps",
    "LambdaFunctionMetricFactory",
    "LambdaFunctionMetricFactoryProps",
    "LambdaFunctionMonitoring",
    "LambdaFunctionMonitoringOptions",
    "LambdaFunctionMonitoringProps",
    "LatencyAlarmFactory",
    "LatencyThreshold",
    "LatencyType",
    "LogLevel",
    "LogLevelAlarmFactory",
    "LogLevelCountThreshold",
    "LogMonitoring",
    "LogMonitoringProps",
    "LowConnectionCountThreshold",
    "LowMessagesPublishedThreshold",
    "LowTpsThreshold",
    "MaxAgeThreshold",
    "MaxDowntimeThreshold",
    "MaxIncomingMessagesCountThreshold",
    "MaxItemsCountThreshold",
    "MaxIteratorAgeThreshold",
    "MaxMessageAgeThreshold",
    "MaxMessageCountThreshold",
    "MaxOffsetLagThreshold",
    "MaxSecretCountThreshold",
    "MaxTimeToDrainThreshold",
    "MaxUsageCountThreshold",
    "MaxUsedSwapMemoryThreshold",
    "MetricFactory",
    "MetricFactoryDefaults",
    "MetricFactoryProps",
    "MetricStatistic",
    "MinFreeableMemoryThreshold",
    "MinIncomingMessagesCountThreshold",
    "MinMessageCountThreshold",
    "MinProcessedBytesThreshold",
    "MinRunningTaskCountThreshold",
    "MinSecretCountThreshold",
    "MinUsageCountThreshold",
    "Monitoring",
    "MonitoringAspect",
    "MonitoringAspectProps",
    "MonitoringAspectType",
    "MonitoringDashboardsOverrideProps",
    "MonitoringDashboardsProps",
    "MonitoringDynamicDashboardsProps",
    "MonitoringFacade",
    "MonitoringFacadeProps",
    "MonitoringHeaderWidget",
    "MonitoringHeaderWidgetProps",
    "MonitoringNamingStrategy",
    "MonitoringScope",
    "MultipleAlarmActionStrategy",
    "NameResolutionInput",
    "NetworkLoadBalancerMetricFactory",
    "NetworkLoadBalancerMetricFactoryProps",
    "NetworkLoadBalancerMonitoring",
    "NetworkLoadBalancerMonitoringProps",
    "NoopAlarmActionStrategy",
    "NotificationsFailedThreshold",
    "OpenSearchBackportedMetrics",
    "OpenSearchClusterAlarmFactory",
    "OpenSearchClusterAutomatedSnapshotFailureThreshold",
    "OpenSearchClusterIndexWritesBlockedThreshold",
    "OpenSearchClusterMetricFactory",
    "OpenSearchClusterMetricFactoryProps",
    "OpenSearchClusterMonitoring",
    "OpenSearchClusterMonitoringOptions",
    "OpenSearchClusterMonitoringProps",
    "OpenSearchClusterNodesThreshold",
    "OpenSearchClusterStatus",
    "OpenSearchClusterStatusCustomization",
    "OpenSearchKmsKeyErrorThreshold",
    "OpenSearchKmsKeyInaccessibleThreshold",
    "OpsItemAlarmActionStrategy",
    "QueueAlarmFactory",
    "QueueProcessingEc2ServiceMonitoringProps",
    "QueueProcessingFargateServiceMonitoringProps",
    "RateComputationMethod",
    "RdsClusterMetricFactory",
    "RdsClusterMetricFactoryProps",
    "RdsClusterMonitoring",
    "RdsClusterMonitoringOptions",
    "RdsClusterMonitoringProps",
    "RdsInstanceMetricFactory",
    "RdsInstanceMetricFactoryProps",
    "RdsInstanceMonitoring",
    "RdsInstanceMonitoringOptions",
    "RdsInstanceMonitoringProps",
    "RecordsFailedThreshold",
    "RecordsThrottledThreshold",
    "RedshiftClusterMetricFactory",
    "RedshiftClusterMetricFactoryProps",
    "RedshiftClusterMonitoring",
    "RedshiftClusterMonitoringOptions",
    "RedshiftClusterMonitoringProps",
    "Route53HealthCheckMetricAdjuster",
    "RunningTaskCountThreshold",
    "RunningTaskRateThreshold",
    "S3BucketMetricFactory",
    "S3BucketMetricFactoryProps",
    "S3BucketMonitoring",
    "S3BucketMonitoringOptions",
    "S3BucketMonitoringProps",
    "SecretsManagerAlarmFactory",
    "SecretsManagerMetricFactory",
    "SecretsManagerMetricsPublisher",
    "SecretsManagerMonitoring",
    "SecretsManagerMonitoringOptions",
    "SecretsManagerMonitoringProps",
    "SecretsManagerSecretMetricFactory",
    "SecretsManagerSecretMetricFactoryProps",
    "SecretsManagerSecretMonitoring",
    "SecretsManagerSecretMonitoringOptions",
    "SecretsManagerSecretMonitoringProps",
    "SimpleEc2ServiceMonitoringProps",
    "SimpleFargateServiceMonitoringProps",
    "SingleAxisGraphWidget",
    "SingleAxisGraphWidgetProps",
    "SingleWidgetDashboardSegment",
    "SnsAlarmActionStrategy",
    "SnsAlarmActionStrategyProps",
    "SnsTopicMetricFactory",
    "SnsTopicMetricFactoryProps",
    "SnsTopicMonitoring",
    "SnsTopicMonitoringOptions",
    "SnsTopicMonitoringProps",
    "SqsQueueMetricFactory",
    "SqsQueueMetricFactoryProps",
    "SqsQueueMonitoring",
    "SqsQueueMonitoringOptions",
    "SqsQueueMonitoringProps",
    "SqsQueueMonitoringWithDlq",
    "SqsQueueMonitoringWithDlqProps",
    "StaticSegmentDynamicAdapter",
    "StepFunctionActivityMetricFactory",
    "StepFunctionActivityMetricFactoryProps",
    "StepFunctionActivityMonitoring",
    "StepFunctionActivityMonitoringProps",
    "StepFunctionLambdaIntegrationMetricFactory",
    "StepFunctionLambdaIntegrationMetricFactoryProps",
    "StepFunctionLambdaIntegrationMonitoring",
    "StepFunctionLambdaIntegrationMonitoringProps",
    "StepFunctionMetricFactory",
    "StepFunctionMetricFactoryProps",
    "StepFunctionMonitoring",
    "StepFunctionMonitoringOptions",
    "StepFunctionMonitoringProps",
    "StepFunctionServiceIntegrationMetricFactory",
    "StepFunctionServiceIntegrationMetricFactoryProps",
    "StepFunctionServiceIntegrationMonitoring",
    "StepFunctionServiceIntegrationMonitoringProps",
    "StorageType",
    "SyntheticsCanaryMetricFactory",
    "SyntheticsCanaryMetricFactoryProps",
    "SyntheticsCanaryMonitoring",
    "SyntheticsCanaryMonitoringOptions",
    "SyntheticsCanaryMonitoringProps",
    "TaskHealthAlarmFactory",
    "ThrottledEventsThreshold",
    "ThroughputAlarmFactory",
    "TopicAlarmFactory",
    "TpsAlarmFactory",
    "UnhealthyTaskCountThreshold",
    "UsageAlarmFactory",
    "UsageCountThreshold",
    "UsageThreshold",
    "UsageType",
    "UserProvidedNames",
    "WafV2MetricFactory",
    "WafV2MetricFactoryProps",
    "WafV2Monitoring",
    "WafV2MonitoringOptions",
    "WafV2MonitoringProps",
    "XaxrMathExpression",
    "XaxrMathExpressionProps",
]

publication.publish()

def _typecheckingstub__5b02dfad72d85267c914e96c01bf8fa0ce42c19f927e7ec13f79575e8eb14beb(
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eeb5f357e7348a2956ac5d7eeeb946ec27a21382a4de10c67d98c171fd8e9ab9(
    *,
    disambiguator: builtins.str,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
    actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    alarm_name_suffix: typing.Optional[builtins.str] = None,
    composite_operator: typing.Optional[CompositeAlarmOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    runbook_link: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2c73b9ece3b1f8ccae4e1b8b67589353cbf8cbfc367672eee37d943e25b0b46(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f6c59609b0d5ad31b391a231c262ad88ec6071638bbc2c2f200e83726dff668(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36376b2db790a761bdac57a3eae2e5c91a8908b1af40ecb90463c9ef6ef49cfd(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e8f044140c9c20c6e311a6b3f7d15c44e9f2ad885d9adb02bed8a8453b885fd(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__278dcde210e24513baf8545edd5c36a214b0e167d71099667eb06b09a55a5e8a(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d530f09f2bd1cb040202791761b41a5c66dd4f747bb728393746d98c8604ffca(
    alarm_scope: _constructs_77d1e7e8.Construct,
    *,
    global_alarm_defaults: typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]],
    global_metric_defaults: typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]],
    local_alarm_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76f30a6274e169a72149ce2908aacf78a821a45ce1227e62e977bcdcc11a9ad6(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b703e3bbae3158b7391198d1073fa418378a8c7827bae974676303ce1b89aca4(
    alarms: typing.Sequence[typing.Union[AlarmWithAnnotation, typing.Dict[builtins.str, typing.Any]]],
    *,
    disambiguator: builtins.str,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
    actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    alarm_name_suffix: typing.Optional[builtins.str] = None,
    composite_operator: typing.Optional[CompositeAlarmOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    runbook_link: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1806c2b56e06aca7469b8b7c8eb99bf73911d1cec0e7c65dbb1a54959252e7ad(
    disambiguator: typing.Optional[builtins.str] = None,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d529ec60c6a287047e76852ff88beeacfbb308e0bc5960475561481b2edda7b(
    actions_enabled: typing.Optional[builtins.bool] = None,
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85e1f9c182eac394694acbb2e460d9b69a7b911e259ed7551b0d66751d24bfb7(
    alarms: typing.Sequence[typing.Union[AlarmWithAnnotation, typing.Dict[builtins.str, typing.Any]]],
    *,
    disambiguator: builtins.str,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
    actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    alarm_name_suffix: typing.Optional[builtins.str] = None,
    composite_operator: typing.Optional[CompositeAlarmOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    runbook_link: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ce541a1f1d438233dfb2c3ba4d9fb2f331b534bd593e765a92f9dc1948326d3(
    alarm_description: builtins.str,
    alarm_description_override: typing.Optional[builtins.str] = None,
    runbook_link_override: typing.Optional[builtins.str] = None,
    documentation_link_override: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46cc2166df47572e3a247df8eb1593665f6107460437a71618d805f31276fa91(
    *parts: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce74e18bedccb1274dd309e1f81086fe1928a283e50611acef614538a67fea94(
    *,
    actions_enabled: typing.Union[builtins.bool, typing.Mapping[builtins.str, builtins.bool]],
    alarm_name_prefix: builtins.str,
    action: typing.Optional[IAlarmActionStrategy] = None,
    alarm_naming_strategy: typing.Optional[IAlarmNamingStrategy] = None,
    annotation_strategy: typing.Optional[IAlarmAnnotationStrategy] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_processor: typing.Optional[IAlarmDedupeStringProcessor] = None,
    disambiguator_action: typing.Optional[typing.Mapping[builtins.str, IAlarmActionStrategy]] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    use_default_dedupe_for_error: typing.Optional[builtins.bool] = None,
    use_default_dedupe_for_latency: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c869e88286e2dfc35509526ef862e0cfb4c42a0649e4c63bd665753222cb46e6(
    *,
    global_alarm_defaults: typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]],
    global_metric_defaults: typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]],
    local_alarm_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__463435460989aaf64b7692dedebe0b8d2b0c80581d3c3d07eb2c1eecd4e34381(
    *,
    alarms: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm],
    height: typing.Optional[jsii.Number] = None,
    title: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a288f9cbedc2527a99cfdce02b50d304eb7ca87e1f84770b7ca0ab2936166d03(
    *,
    action: IAlarmActionStrategy,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d25bb5967177f38d05439f611826798ffb0b415e4c23ed717c4b6dc280ee9de1(
    *,
    alarm_name_suffix: builtins.str,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__47462653cba6d57de993c3c3c9ba4374cd78d9cc6f6789e80053f076539808bb(
    *,
    alarms: typing.Sequence[builtins.str],
    title: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f2355c8da2ac06f8dd3b82e21a273b452d42e2a6ecbcd9436edf48426384acb(
    *,
    height: typing.Optional[jsii.Number] = None,
    region: typing.Optional[builtins.str] = None,
    title: typing.Optional[builtins.str] = None,
    width: typing.Optional[jsii.Number] = None,
    alarm_arns: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8606c0117095ab9f7dc09c615dcfe6943276093179ddf454ed85256c77bb9047(
    *,
    action: IAlarmActionStrategy,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
    alarm_description: builtins.str,
    alarm_label: builtins.str,
    alarm_name: builtins.str,
    alarm_name_suffix: builtins.str,
    alarm_rule_when_alarming: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
    alarm_rule_when_insufficient_data: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
    alarm_rule_when_ok: _aws_cdk_aws_cloudwatch_ceddda9d.IAlarmRule,
    annotation: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca1dd234346f02605e07e5918b0374facbff98d61247fd2587d6f1ff699e2280(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d863399e1672ef027989f01638846f5a0a3cc8029ea4e58174909946a6add25(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    alarm_name_suffix: builtins.str,
    disambiguator: builtins.str,
    *,
    alarm_when_above_the_band: builtins.bool,
    alarm_when_below_the_band: builtins.bool,
    standard_deviation_for_alarm: jsii.Number,
    additional_description: typing.Optional[builtins.str] = None,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c267e31c8cd5c1bd0e3b8ff667c6a95c1fdea3d6830e885260dc17f2e9cb7176(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    evaluation_periods: jsii.Number,
    threshold: jsii.Number,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_name: typing.Optional[builtins.str] = None,
    comparison_operator: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.str] = None,
    treat_missing_data: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45099e6670c87a932c599eed1c0ba693bc08493523432b141bc6248da9d66b3b(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b71ef0b811f575d598fdc0bfa08f194d6c45d1a3f0a8c673c1b44803af6830c3(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HighServerlessDatabaseCapacityThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a302367485dea2f83d283bbffd3a30fcb95f40c4aab9c2fc59ae45bc5c3bee2(
    rest_api_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f9fa931f716446770b6198d959d612e3e1f62b9535416b38c81f376bc96b406a(
    destination_url: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5d2fc341bda8f3937b986f45b4004713a1a325e885243d595bf5dc36ac086579(
    distribution_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ccbdab9ee8ad9cd94af10d8759710d20f8ec418a5aa43f570d63704ed363e51(
    log_group_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1721206924f1d4352cf8b628a428534fea6e7d4f148379e822a4eccc1476f21e(
    project_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9ab81f8eaf1a584f8044af6409095e094493e7ea72f8334d6d73ce8bbf245f9(
    cluster_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__517d326fd9bec70b977d583a7e8fbcdda18affe19817256e3006e7c72a5ec17e(
    table_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d14f1c234d8fcbd3c9f838e3a0bbc944d0fb0e37ecb635c0556fd2e8ed4550d9(
    cluster_id: builtins.str,
    cluster_type: ElastiCacheClusterType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51bfd6615794af62e068fcf0162174cc3c655c65dd4ada1851257e8591cfa0d0(
    application: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b052496cd95fd34ebd8344edaf2425648e45ff739a363f89edde8b084c427135(
    stream_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f800b688b83a46e9337c3a5cf2d0f188d99cf0b4cbce5d4c5def309d19898450(
    stream_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__26577adb183f727fe17f3acfe2f1dc664554523a62ab72d895cdbe83ba547680(
    function_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__91f4dae5dfbeff2df56e88918e374bcfefe4e73b54ce769c16ed71a1b74bf13a(
    domain_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc3c719907418142a6760e6679e5abd7ac2fce675800dee9dbb5a8cef07f051c(
    cluster_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__09cebd1b1aa6a2b2e8eef50543b5ecc8686b3929e0cb6d45d7f1c048b92227d6(
    instance_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5eb33a5fec989cd265956e305af30c9ca8d089e8fa6dde6a824a3e5c1b4b5a0b(
    cluster_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d66ed73316f4263813d06b35e95be33d7add9f32c7f66eab4789bb7dc497cdd8(
    context: _aws_cdk_ceddda9d.IResolveContext,
    destination_url: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57a7a331c5bc38c2efa83af3acf5aadc8f0e1f31a8acc4bef61ff5bd97835ed9(
    bucket_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f053198c3999248b019ef20efca56a15fb7d9a7545a611e7367808f4c7056510(
    topic_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__acff584563d9cf4fcec3d3a8cfe679a51ae080d79e4d74fb083e56e0cb56591e(
    queue_url: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f73d101afd1bcf37923090d1ab5aca645a37de07af1ea5d4c6ecdad526b6a0fa(
    state_machine_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__01d030f40a3e16e59f7cf96acd793162b9493d52c448708f2eeb5f27856ffb12(
    *,
    aws_account_id: builtins.str,
    aws_account_region: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19230e48c8ff23ffdbc393eaf7cc2cbb30370671bec7380cf3f4038e545692a9(
    *,
    add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a374d2a14038e603b79e04b4726864a2ba272f673f6d649bbb043b631daec26(
    *,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f50ae327b5e929f8c9e2af7139056c8e677547504adf6c776c2980f3ff8013de(
    *,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93a1c712a97fed26164b9d1fb242034019fce862ca9c7faed6f8cd35a1028fe9(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b2d177ffa9b34b3a77f6fdf3c77be3cf2cd6412c94950cd261c8f7e295e2ede(
    metric_factory: MetricFactory,
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eeeb06047be2392f291d4ecc7070ca9898aac57cc808d2336cb9cdcabd5185a8(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__724fa79970d80d56207f37e702ab8b4763e3ffdaa57a5d5657c383f807fa6aab(
    metric_factory: MetricFactory,
    *,
    service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c1d711261770259d1a4936b895bde5a1a8be59ffd7b4ae5072aeeb7da1cf6de(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b777bafd865107e9ffeb5eb6f71437827d8cb2d8e1ac28cfae56c2581175fd5f(
    *,
    add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5c7742b8b54cb6637a8a37e189f49a77759cea15bcf58867b00f58b2202e86dd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    dashboard_name: typing.Optional[builtins.str] = None,
    default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    end: typing.Optional[builtins.str] = None,
    period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    start: typing.Optional[builtins.str] = None,
    variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
    widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5b5470e02a552bb0f6e8dec61a319b082b25e94f192aef8457b0666311b05631(
    *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3663a57c2ca48fdc1f40cbf61227072b6790c447c88174fd56975128c585e23(
    widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b19e10e301180ea922526542acd6aaf9262e183c51917124faf22d1f01d4c4f(
    *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f271ada55f3c1300be52c5b0063d88118bede583cbf6759108eb757308467494(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4226316e5fef6d2d87c15b71fb429fcf63e54ef78a81e473e27c86a202be1a0c(
    widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e1c6b21948df5c652d071f244ed6334fa28ee0399c526280faceef8f40ac20a(
    widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eab5a40604a68835b050f9b6ecc5f93e172e7f9bcb3f0139868546c26ccf9f19(
    metric_factory: MetricFactory,
    *,
    certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8e364cfec12cd462f50660f97c3bf53e934bdb1a965de5f08b03d57e643715d1(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51016d5aa3f742c63e4bd2330ab30b53e50b5404648f41485b81306c7bd53328(
    metric_factory: MetricFactory,
    *,
    distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
    additional_metrics_enabled: typing.Optional[builtins.bool] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c62e4f3c4f2a6d30b58488d308c3dd35c2fcf1d3331e1c833b4decdc502e0db2(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
    additional_metrics_enabled: typing.Optional[builtins.bool] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__132d4f88ef2dd98258ecf737ed4053a56e55a5bac58f99139eca25252c965ec9(
    metric_factory: MetricFactory,
    *,
    log_group_name: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62ff5f24f59a5f1f7bec002b977c9b749b44eff7b5bd8f7a1753bef6d0463227(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    log_group_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e6882a6e0b4d9af8419c13145a314aa19c28a50b6044640cdb6fd6cdcb778212(
    metric_factory: MetricFactory,
    *,
    project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a7ad72f83c2048841ad0d74a88559e7732be4ff93729f3422257c091d44af36(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1a1c5ddf32a40f63f59e22a5da82a7d60c1f420ffc263c51d8c4a36f47a9071(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a142674c555acbf9fc18df0264b147e50496559a37b5446e32196d27409f6a0(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__40bf0e6097ca47d51c20f138fde28f5e7f35ea7a08063bbd9a73b152b873a211(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__842fd90292303bf62a261b8bcaf342b053b2038bf348e7fb77eecda1e2e1d44e(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92ff4f0824fe03c42a578a27e0ce8f4509ba6900a2d8a593b6c1ab952b524c5b(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    alarm_name_suffix: builtins.str,
    disambiguator: builtins.str,
    *,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    additional_description: typing.Optional[builtins.str] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f608122ff7ce6fe8ec364084d27bd6e7336b135d26229dfb9e896b2591630613(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1f1bb77a9f08688389701943793f9fa232e3af630420ea5ad5a5613e0ececc4(
    *,
    metrics: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression, typing.Union[CustomMetricWithAlarm, typing.Dict[builtins.str, typing.Any]], typing.Union[CustomMetricWithAnomalyDetection, typing.Dict[builtins.str, typing.Any]], typing.Union[CustomMetricSearch, typing.Dict[builtins.str, typing.Any]]]],
    title: builtins.str,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    graph_widget_axis: typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]]] = None,
    graph_widget_legend: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.LegendPosition] = None,
    graph_widget_right_axis: typing.Optional[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]]] = None,
    graph_widget_set_period_to_time_range: typing.Optional[builtins.bool] = None,
    graph_widget_type: typing.Optional[GraphWidgetType] = None,
    graph_widget_width: typing.Optional[jsii.Number] = None,
    horizontal_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    horizontal_right_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    important: typing.Optional[builtins.bool] = None,
    vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7619d758dc272ff2b4dce9aa14e3ace0f18384f3dc45801e8569a8e01ebe8da9(
    *,
    annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]],
    metric_group: typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]],
    right_annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]],
    title_addons: typing.Sequence[builtins.str],
    vertical_annotations: typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]],
    height: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__63182d2487fd8c5519734296bd6fa20b09a86af420cdcfc68cf5fdce11729f57(
    *,
    dimensions_map: typing.Mapping[builtins.str, builtins.str],
    search_query: builtins.str,
    statistic: MetricStatistic,
    account: typing.Optional[builtins.str] = None,
    label: typing.Optional[builtins.str] = None,
    namespace: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    position: typing.Optional[AxisPosition] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c50968ffe9bb26017e4152c62ead0d70defc2d1fb006cee54d51da2655be411c(
    *,
    add_alarm: typing.Mapping[builtins.str, typing.Union[CustomThreshold, typing.Dict[builtins.str, typing.Any]]],
    alarm_friendly_name: builtins.str,
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    position: typing.Optional[AxisPosition] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd04f74ccbaa026d25c1b7ddcdbd55714e125815b7244320fa40a7823c5e4847(
    *,
    alarm_friendly_name: builtins.str,
    anomaly_detection_standard_deviation_to_render: jsii.Number,
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    add_alarm_on_anomaly: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86d5216a650bd624bbb710741fab50af24cb71cd64afb9218797c39b3d0b776e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    additional_description: typing.Optional[builtins.str] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__531a5bc64d0774422bc4d022016267f620d37e8f4fff3d351a5fa8bfdf1b6f6c(
    *,
    handler: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    handler_params: typing.Any = None,
    height: typing.Optional[jsii.Number] = None,
    title: typing.Optional[builtins.str] = None,
    update_on_refresh: typing.Optional[builtins.bool] = None,
    update_on_resize: typing.Optional[builtins.bool] = None,
    update_on_time_range_change: typing.Optional[builtins.bool] = None,
    width: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efea1c7e65336fd9864d4a3b0a38ab06f6ddcae24f08fd2fe9bbec10ec81c98d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    dashboard_name: typing.Optional[builtins.str] = None,
    default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    end: typing.Optional[builtins.str] = None,
    period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    start: typing.Optional[builtins.str] = None,
    variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
    widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__432599f8be82fbd24f8c0c66d2819b3704dac265c14e6d6541246f2bed6cc549(
    *widgets: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e7fe19ca3c7de381684ba80b4bc969bdd0f480630f5062050ed7e3e6059176e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_days_since_update: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a8ddb414e1cc2a15374c19ecfdf14ed7966b5d0b8066f5ac7e9dff750d06e2f(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_days_to_expiry: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f744557b86a3e2dd82ef0e8a3ff586154696228f1c5a43ce1d69e2c9c647f100(
    metric_factory: MetricFactory,
    *,
    cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e314657e74051bf9e0b8cca0e6793875851d1c18b0733e51165864325ec76e3(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5115987173ad680caf08db054b2ec113df00b3e96a66ec24def122a90b5b9827(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__677e67c893b039647efeb1826c8d754873b3949c149bef9497417f2e4fea236e(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a59f2f11bb83665e0b2fdf65e6a8a6781f794062ea2b2791fccf96a0d421324(
    *,
    height: jsii.Number,
    left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
    left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
    right_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
    right_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
    width: jsii.Number,
    left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    right_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    title: typing.Optional[builtins.str] = None,
    vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__24b978702f49c7ab143fcb30e1776a46fffc7f211ee09c8723117cae8f591c13(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_duration: _aws_cdk_ceddda9d.Duration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d263102eec892d25eada86016f8607a70697f322c8d513e5025fc6197c7379b7(
    *,
    name: builtins.str,
    period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7c6b95e38184075c84ce55e5a093bc8065febb005edac9203aa9c991822caab(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf23b15019ca557aae9164b0b671eea28217d46e93d7ef6cb1fab55251f01636(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    capacity_type: CapacityType,
    props: typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1346d3b1420f0068f0efa6e6040ee42ddc2f695f04a37dd8da4bbc573b550e64(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    capacity_type: CapacityType,
    props: typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1e3547a89f425dbd496a2b79f75bf6e4cb7065cc8e8d0a72a07889a701459e17(
    metric_factory: MetricFactory,
    *,
    global_secondary_index_name: builtins.str,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6efe7d6848c98376653b9f590f321bccfdcbb580069f7214295323136cc10e30(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    global_secondary_index_name: builtins.str,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9a2743a9ac4153126591046f987a71aecd551181ecc471d4813815b3983148c(
    metric_factory: MetricFactory,
    *,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8cbd6773e7f4f1a6a1e38362c0a35e7e413ea0d112b05605693a599a8dca25e(
    operation: _aws_cdk_aws_dynamodb_ceddda9d.Operation,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc8768b4396e945566f113089cc90526366e442f8102e472f4b974a1c233569f(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__218ed60f91855f35c191ca3ddc8cc11bf49a2e371e24d185520024e461f0e7d1(
    metric_factory: MetricFactory,
    *,
    auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
    instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a218e7e1b45c349f734abce1661cd3508196a5031d9ecfdeca03659f8018740(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
    instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__484631e89adcece39fd4765fc1aa1c50ffe9b8df7ef544e96ecd015bad528bcf(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1c298e54d8e007efd6bea77f5e962b99e3e116c5b89e297e301be4a724eedaa(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed32a56a8bb5411960d315b45d0320490084a95b6aa77f38dda6b971827b5d01(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83dba0afa895a26337988cfe24b4996c98fa706d24bbc8dbf321a0d8784ebac8(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__381c5847b0669e07118eeabc12a039a832904d5483ef4530899da4adc76f8be4(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d082882f88bf56e0fa8f757ead3c858ad46b6419ec4c2ad314623a3cdd6ab118(
    metric_factory: MetricFactory,
    *,
    cluster_id: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68b3e75615fe2c1f005943c7ee6fa7432e05212e072fc87dc84dbfaf4b37d5fe(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b798d9b29818feccf7fb6b758c97f3d35072783ebf9f53c564d96d8e185aae63(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfb7988e55977febfb96841b2dec4564ac02cb112410697ede137c527552a84d(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    error_type: ErrorType,
    props: typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3af36fc1c41feee2b22cbf398a88e95d1b12224804adc48d5b0cfcac3e032eb8(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    error_type: ErrorType,
    props: typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7936765a6e7ab5b5f411259975f394820a7710e193cefbc38809b24074fb862(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_error_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2c2fbac7029d34d09846a42268794092bcb930b46d3460d0efd55e42d5fd763(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_error_rate: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f17a785fe075a84bc01e9474022d125b8ff1bcc4072f2fd8bd4e83a5c4344de(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    safety_threshold_limit: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3765d3874fc2fc4405dc3b002bbb7bac24437ce2250616b353c1bb13eab8e0f1(
    scope: MonitoringScope,
    *,
    namespace: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b2a8a21124f5085635a7b4c0036b0a849bf587e7a766ed12a950e08dd6c3dbfa(
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2fb350e11b0c39f081eba61ca2f0a8a1cdc6b98da7aa235ee70270ec3e2ade21(
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cabe6e69f921aa33f7a1b0a93d7d6e970689efb2733855cda7cf478608ae5c7e(
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a6d9fb498a44a3d834237badad56f0a25c4b1cf143735ccc0b2ed29cd861971(
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b49eb2ae5ea59d00284ae5354f9265a8ec45df1c9097e8c8c27cc5a55c65381b(
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0cf5ca8686eee80f35aed3cf0dc778eada5a2e340285ebc5c324bc5547636e8(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    namespace: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__493576f7ee1b6c6a0a587e3b6d6f642f62893cf1e704ab683a55e1cd6cd9c401(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_full_restart_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__98bdc6dfc6686f05ae2b3a4d9df00b5cb97c123c609ebb25289f3f2c7bc93f9a(
    metric_factory: MetricFactory,
    *,
    job_name: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18080bbf6d8f19ce6af6a910d75a1cf65d21fb8fce0b28bbef404905cea12f20(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    job_name: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8452da4f6b5065fd434c71097cb8ddadce18e3d2d091b38d595fc61a367a135d(
    text: builtins.str,
    level: typing.Optional[HeaderLevel] = None,
    description: typing.Optional[builtins.str] = None,
    description_height: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2dad5289ff410a934ed29cb1b3b9f16cf8a9f9c081c52178409a559dcb9b51c2(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_healthy_tasks: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4213149b310c43260bfd27b4a2029af44f7441e4df21d00a6b56ab57a2672d1f(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_healthy_task_percent: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd56bb0feb49df06a9e24215d9f30cc15793eaefb9f9669e919a0c26f4b259c1(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_connection_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5d95e83cfa3ce3f79486413efe2394c6166782838522119af352612862b9c57(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_messages_published_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b99e3034e8dc72ae2c72b88e869515639198c72c514ad3eb0b60feb3f93202b1(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_serverless_database_capacity: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__20ca105ebab6067ba02671047e2de412309ee2bb598dcbf9939b5f310e4e3b6c(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_tps: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e5aab12c7cc961978dee44d87bdaa59c4d77175ccb3e36dce00e6602897b2b6(
    alarms: typing.Sequence[typing.Union[AlarmWithAnnotation, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86a300e39af732a6f54f906c48c9bfbf5a02208a7bd1c89748ec3ceeb6163225(
    dedupe_string: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf8c6b1cf2894a44ed43da1a4dd392a5ddf232bf6911240b2bb6252ea271d67c(
    dedupe_string: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14f69a2fd3762c4e28115f4947a4ee18d1a794405c07e6329122fa01de805c99(
    props: IDashboardFactoryProps,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1e2d7801562ca386fb22fe1b52137d1310f9ae05b4f775a5d81c2c633ab151d4(
    value: IDashboardSegment,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92068ccf45f20a97a903799d5f4ced73cc46987fdbd0fa577d0f059be6b6a210(
    value: typing.Optional[MonitoringDashboardsOverrideProps],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__715834be628205872aa4a68b265113a7893b966209c85399866f30b58fdf36a8(
    segment: IDynamicDashboardSegment,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2cbcb4b5ea45177c015f37a96e309eccf6d6f2d041c1661704031f69cc0222fb(
    type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4cdf844d61bda5925165058ea69f4cd34fb67b5a07541d38a9650c07b1cf28d3(
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__756b8d4ba4e6bbd19b072835fb6ed0dcd7b4cf9bdc9b2977a9d845a19a9e4b78(
    metric_factory: MetricFactory,
    metric_name: builtins.str,
    statistic: MetricStatistic,
    region: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7b50fa294bfdf30d95b7378ba0618b45adb742252b80e5bc142f9008cb29386d(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    alarm_scope: _constructs_77d1e7e8.Construct,
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d4535512a7278de88237a352bc5944518abc94df103342b85b242a359bf289a(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a7180ef7acfbd0714c754e22af84bceab59958bf156c9be01ed62a90858cd35(
    data: typing.Sequence[typing.Mapping[typing.Any, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6dd9be0e7dcdf4bbc79b28d19672877d10184a4150a2ba7c273ef5d624d7c0da(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f27d500a1f668700c6dd5cc99d0b0b55535bed2d47ae9fd3296d6d3e8be4570(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    metric_name: builtins.str,
    quota_name: builtins.str,
    props: typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4342315b54978991364a3d38136eb7222f5dfd2d658194e2e0fd19d21da7a830(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0632274c7089b3d1190d01ae17a0fc4f9a0224d609104c369a5a47c76f5d9a9b(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0e6afbc022dd44a68c5f19767e5cde81611cf75cbefacc0bbb62caf8e2979070(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96e318f1ba95cf6f77db97209e23bc1f51692ee44cb6cdeb55cf5c21c500cc90(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c42415b274d089b6cc85437de60f7671285ff979dfd3ce26904ffd19e2b3e52b(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__543b67aa776edb6ab9e9aed08d5cb0afce0593c03a60996f3771cb69574bbb50(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a03a966c633e54fc2818bd65be9611e209675d39d8ed71fc9a0ef3a92993a48b(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1d3085719d63885435613ad4b3364f97c6adf2d557a5c29238b8d1ee5cddb1ef(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67e44fbc693d7e87af28a9dcf560c7ff620725d581d30878bb17f49b6d00f65d(
    metric_factory: MetricFactory,
    *,
    application: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9610b685c3b1376783f98e7df27cacf2be380051dcd102d22a37e000c6b0c224(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    application: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3918125a5d3905ec68626a9f418339a6c913c8d0a72084aa6e37f06a7e2da8b(
    metric_factory: MetricFactory,
    *,
    stream_name: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__991ebdd106f63e21f900788119601e6e9ce132434afa7b055c0de61a6bd12cfa(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    stream_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d4914092ddef90fcab0372f0a295ace80e27f997d3ccb4cfaa8c4f97727ce02(
    metric_factory: MetricFactory,
    *,
    delivery_stream_name: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b4b05bc023bb7a539dd6ee30c6b1a0fedd0f85fb403852461b8860395416d2fe(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    delivery_stream_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c056daff833342aaad53d9c459eb320f2cdf8c0c47dd4547e32e773f9f265ed7(
    metric_factory: MetricFactory,
    *,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e01c704e5bf022528d7de17fa670a27e0a1dabc0fd3232ac96b9f3ad59d89732(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb07c97b9ee2af4674cf713920412a7196dcdc445c3772d680cfe0e9f526bde3(
    metric_factory: MetricFactory,
    *,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    lambda_insights_enabled: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4443c4a6f306040bfe5c97d5c920c2a78529b4ccce8d61cee8c62b0ca58a1d0e(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0594831587b01e96a9eafee1a5db223a92bd8b13d8eca89a3a2240da120e160a(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    lambda_insights_enabled: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5d635d1b0799154804c26199390dad5e1059ba6ed13745ff11bcb549f983abb4(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e8402fb9facc4bf7ebc33548dda4d5d5efb3d74e2c18c797d4dadad22f3a1417(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    latency_type: LatencyType,
    props: typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
    additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1e7db01f529db91182babf32c97d70a3b465087cc27ca154ac06895f42e12165(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    latency_type: LatencyType,
    props: typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
    additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c15e6011691ef74eb0e27592c4db2fd68c00b94dec1c22a6b43cd2b4e348b15(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    latency_type: LatencyType,
    props: typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
    additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__65bde4b97f808d87d55d57785bfff3d5e0af30120a91131acb14e5423b62ff3a(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    latency_type: LatencyType,
    props: typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
    additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0b22a4e1dbb3bedfea9b67bbe930f82069af29940f61f4bd27b3ed1719fff2d3(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_latency: _aws_cdk_ceddda9d.Duration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd09c279db7b5399f505fd93fa6a43bb014b32e89d7fc5e436edd7b9abfe6694(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2de76ea3bb5a1ed963336c93199c27f04299f8d426087748a5066ed89f4dab94(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    log_level: LogLevel,
    props: typing.Union[LogLevelCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a734964a068eeff03df1d9d7e0385c2e22bfb83de84c30fdc0a3815cf4bd1ca(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_log_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b7bdfb77e5e87ee7537a8b99d5783aa5de8929de5236f6d1a2c7abc496730581(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_connection_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ddbc4dd2acbb7bd0cc90993abe98b1f02aa9239a8d6ce6c9f857a9d6ab5807a(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_messages_published_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__15dc471f745ef3ae7c8ed37bb1f8ff889bdc9de117a145fe5ff7db6c793b4573(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_tps: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eba07c131f24675f68a137a4ede435f0b00239e75adadfd3e42b7c1aa01b912a(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_age_in_millis: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b74d9265c1413488b86e752c79101fe405c6ca8a738be88a15dd5edc4705b1e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_downtime_in_millis: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3bcc1bcb55ac8bb9d7d5339ba09dd551e9caf80696269e6af62618a80e42679c(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_incoming_messages_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__343d60cc15d8f92e4f7df5b3fdfa45d31295f776c7078a65bc33ccb2cbc022de(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_items_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__177fcea6eb23cd9ca7eecc32eed547e9a2e6eaa23c842f42d41f29a441effd1c(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_age_in_millis: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3bab2c0fc702f4f6250ce5fe55e971cafeacc720a174484b6cc9044940759fb1(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_age_in_seconds: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a95b1b927453c4b8ab8a15dcadd6fc1aad50d0bdec761b4a49050d1e4fe4d75(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_message_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ac019cbf25c3e8f4bc59bff3fa347fb614b1f68872e5baf8b2d5b07225a2c1c9(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_offset_lag: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d94c289428e4b3812e4c81eac89eb86383cc625051fde3f08f8c0b25bb23abe8(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_secret_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e96b576e53a2b7d3d911126d7aa02542f7bf9e2509d8044c6c0310beca2d815(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_time_to_drain: _aws_cdk_ceddda9d.Duration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83399255159d530e9a79076bbc9dbe83b8914317540586af8190fd23568165b0(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07531ae0edbbf677c563d7b56977689f9f7c8db7bf304d036c011d6a2c0f2593(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_used_swap_memory_in_bytes: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87020e89dff6230d8f03e63fe678970d6847e16fc1bfcc16b459a216e70d78de(
    props: typing.Optional[typing.Union[MetricFactoryProps, typing.Dict[builtins.str, typing.Any]]] = None,
    scope: typing.Optional[_constructs_77d1e7e8.Construct] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a0f2cac0b013b53e24ca2cf36ddb1260dc1a50a173dda5ff24a8242197fbcc68(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__88cf78f9ec04a85a3b73174430c3d60ba8c1e9f0ccd0f08c25436de573b2d227(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__866bac41d86ba9c0aa7c1bea0d225f31040de1664e562c08e20e996b03927f7c(
    target: typing.Mapping[builtins.str, builtins.str],
    additional_dimensions: typing.Mapping[builtins.str, builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e65896875d1f2b1b8ef0d32fb7451ff3bd30f36b9e04659b8f05b8dc9bfdb81e(
    metric_name: builtins.str,
    statistic: MetricStatistic,
    label: typing.Optional[builtins.str] = None,
    dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    color: typing.Optional[builtins.str] = None,
    namespace: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    region: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a446bf6dcc8a77c636c0d2f5a970ea8b8af73f22c143bd75bad8158b7361c7b6(
    metric: _aws_cdk_aws_cloudwatch_ceddda9d.IMetric,
    stdev: jsii.Number,
    label: builtins.str,
    color: typing.Optional[builtins.str] = None,
    expression_id: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    region: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6330b44fe9753bdb63f2de387682ea84cac9f6427f48173cafafa49ee1abe91f(
    expression: builtins.str,
    using_metrics: typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
    label: builtins.str,
    color: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    region: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ea2fc908d5272c75f0c20a5a4e593bf8ec782ad3db61b3185f6a6dc73a55b8d(
    query: builtins.str,
    dimensions_map: typing.Mapping[builtins.str, builtins.str],
    statistic: MetricStatistic,
    namespace: typing.Optional[builtins.str] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    region: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aaa0bbf1e29ce34520197ee75922fd010882112aeadac0330c1d49d567a03e37(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    divisor: jsii.Number,
    label: builtins.str,
    expression_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4af36769d31c793c646f96ef988415069be99c6d31e9c3e6a73f8394b2220b67(
    value: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ffb960f2d5315d4ffa5046d853b50470ffa4d31cccc2a58791f819a5ea0060be(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    multiplier: jsii.Number,
    label: builtins.str,
    expression_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1d238382709ed89b963f3323acad1c91079640ec6215e318662ff0b4adf9d75(
    expression_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6443e995125fc081fe2fe171583b9aa63a1911c17b96695ee0ce70edd047e70(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    method: RateComputationMethod,
    add_stats_to_label: typing.Optional[builtins.bool] = None,
    expression_id: typing.Optional[builtins.str] = None,
    fill_with_zeroes: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__df57e062e7d88eb2f2865b70e82a9191fdb782bfe6268046c10bdec78789d4e1(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    namespace: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f45f196b0d9a3e2fa1b57860efd2c9ed85ce8a4354aab4c9b818381abce63df2(
    *,
    global_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e71e0b8c1d99b1db88de5bfc17a53d4e99a744e3ebcc4aa4f56ae726af7780db(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_freeable_memory_in_bytes: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7c7406d35f20af74b8f9b9812a27f0fcdc19edf2c3c24a241cf6fd5cc0709025(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_incoming_messages_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e86df53f4be5abd3ba4c03f389ee81a413826f3a3157366551e7694d5657fc42(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_message_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2d3d52f4ae987afb2ccb70baef64ae9641aa5c154538fa8f053b525c21a5135(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_processed_bytes: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bd707297df29d4f351c909ca37deb4d16a7d302aaae89615693443a404d37c02(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_running_tasks: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__03bc7bb921d6d3dc1ba1941eba1eedc413e7e4339cfe71d35f249d2ef36ea8b4(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_secret_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d5dc68520bfab68b018f19a1c3f43d98a742687a3b0007dff100e8a0837304e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1756f17ca9efa13a3497f07fcaa049b4483d5a440293ad9c1625a1f27e143123(
    scope: MonitoringScope,
    *,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__abb59c5ed96be70b1333d46e794e8225b3c97f8855e992451fd7502363bbfb88(
    alarm_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b12926dcd1d8a2c178228c89f5f2683f5d7064fb09fc13087d5d63a7f1ee9052(
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6901860bcf3b0545043f3b3d08fb673a71ff9d423d729c3306f97f0e0a03ae5d(
    monitoring_facade: MonitoringFacade,
    *,
    acm: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    app_sync: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    aurora_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    auto_scaling_group: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    billing: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    cloud_front: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    code_build: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    document_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    dynamo_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    ec2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    elastic_cache: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    glue: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_analytics: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_stream: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_firehose: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    lambda_: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    open_search: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_instance: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    redshift: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    s3: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    secrets_manager: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sns: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sqs: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    step_functions: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    synthetics_canaries: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    web_application_firewall_acl_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4185d86551c5e33233fc7123c80e4723734199b801bd1d89df477d783153074a(
    node: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34933099e595bccf3bf326147d8e6e6e1a8db2c126e288a7a3aa41cb6a1d969b(
    *,
    acm: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    app_sync: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    aurora_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    auto_scaling_group: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    billing: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    cloud_front: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    code_build: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    document_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    dynamo_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    ec2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    elastic_cache: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    glue: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_analytics: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_stream: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_firehose: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    lambda_: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    open_search: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_instance: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    redshift: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    s3: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    secrets_manager: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sns: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sqs: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    step_functions: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    synthetics_canaries: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    web_application_firewall_acl_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b29f63ffaa6a077b48061c895deb13e392edd41edbb04e4d697c49ba71d3867(
    *,
    enabled: typing.Optional[builtins.bool] = None,
    props: typing.Any = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cffb3bf01cde969b1448a7c5f8684dd36613d7a76aba8b9a49c43d0d428f051e(
    *,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__901755619e0c3833c4ed1087c81e3359bea6187173fd9404433aaa0b68ae1ac4(
    *,
    dashboard_name_prefix: builtins.str,
    create_alarm_dashboard: typing.Optional[builtins.bool] = None,
    create_dashboard: typing.Optional[builtins.bool] = None,
    create_summary_dashboard: typing.Optional[builtins.bool] = None,
    detail_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    detail_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
    summary_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    summary_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2062930491aa62ff0642d6ee7effbc58a68f2bbe7b3b838694d8835e4b32143(
    *,
    dashboard_configs: typing.Sequence[typing.Union[DynamicDashboardConfiguration, typing.Dict[builtins.str, typing.Any]]],
    dashboard_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b10df49c97391750f3ee7be142bcda1b1de8f475cecd2f8186c7a8a8eb2d1a40(
    *,
    alarm_factory_defaults: typing.Optional[typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
    dashboard_factory: typing.Optional[IDynamicDashboardFactory] = None,
    metric_factory_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__205330df233bfe702239b5f2e913755a42ffd47938ea54ebf2a9aa812debe4a6(
    *,
    title: builtins.str,
    description: typing.Optional[builtins.str] = None,
    description_height: typing.Optional[jsii.Number] = None,
    family: typing.Optional[builtins.str] = None,
    go_to_link_url: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b09b1f5d191cd8e787689163463f845e0d890bb82bed7a361c8f905b136ca4be(
    str: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de511faae7c89568fed81eaa0ba4ef61b7e6333b7291fb5f9f8c3cda860b14a3(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd385a9a7a83dc160515e6a3b722ef5fb7187d1edd59792b5a90673dc605c40c(
    alarm_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1009a27461c38955fada021253e70e1517e8683381e00c41ec1cb274bc948207(
    actions: typing.Sequence[IAlarmActionStrategy],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38d536fd5ef6e758bbd4ac0ca5e2859bc4382a10b3434e8fb9b0024a60476b15(
    metric_factory: MetricFactory,
    *,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7eec06d575009bc57ad27e91dfd1f4de9c39fda039bdc3f4e44a7f353eafc2c4(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35376777fd4b34298f767673143427e2a3257d10aed099ed6d3ff925d78a4099(
    scope: MonitoringScope,
    *,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__214e33afc094333bb1bb8e85fd453f383093947262053f56f937351682b7c119(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c5e9d1ba2069fa46706876a01bcde7e319740f572418f1ae2b1d2d9af643a9ec(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e2bae971dc5eb03e121443ef75bb1cea6396f632ba6a6dcf24146ecc8dd6acc(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_notifications_failed_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__315dd7ab3935330444ce7108bcc350c0f76202dbd5201f278518637a8ad9326a(
    domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__80d9d0eddf06c2b9f82e9100e43901436dae7b2a2d08a843152438517bcfed1c(
    metric_name: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    color: typing.Optional[builtins.str] = None,
    dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    region: typing.Optional[builtins.str] = None,
    statistic: typing.Optional[builtins.str] = None,
    unit: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.Unit] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57edfc7c5ec3b6bf57f1ad80dfb371d230cbb589697e125e597b19d57d60ca3d(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4222857ad5e5addae3c0ac2d3d8c4f21df08b2cef18ebb39c8909735617d7caf(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96f98b934af9ba6c2c97bac53a10b60c492c18e89e82a8ec1e87a0a7b6ad1a29(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__afaa25398d400d3e6a13a5a7c7e53370e7731919d8dc70c2c0365661651fae3e(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f9e0176dccec25279501dab4b551906455b7b2f7276ee7068d9ada81b0b72ab(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a8fcb3bb428f198e295e205a3a921bc996225791233ba57abf09179f3e6f5cd0(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6c9f69b29063713182510809f226bce441b88bd1bfafaac0680059f9f9417ea(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c824343009a905b4142a504d4789282fd725dbe7a660597a0b7c441bc15888ec(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_failures: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58f4591dfa92ce45813ecad65c208f6ac00e3a87310078d33dd39823bedbb39c(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_blocked_writes: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__edb80488c11f669647af177f6a06a825f7e9392abcc3e5214a58953d9fe9629a(
    metric_factory: MetricFactory,
    *,
    domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d7bd8a2864ab2bea095b2b1bbd29a11ee6cc6ecf2652f29b5fbfe39c3b019e12(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d5ae6732d6b6c075d18656168a7b5351e10eafd44ed610aef6295343b126fa38(
    scope: MonitoringScope,
    *,
    domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36a18ce2f05eec38f0c69162425d6ff347ac76d6c6d83e52dcd465d995144238(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_nodes: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0efb3bb54f27e195961602f31559e6117a91b9960cd94b1348aa20bc2e69c541(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    status: typing.Union[OpenSearchClusterStatus, ElasticsearchClusterStatus],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3eeeaeb925a6417103061edf178b6bb16203b9e9c13f8b1b8669091768fbce15(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_errors: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca90b7793b13ee17159fe4688a54a129222f7d2da81e0ac774a68fdc410997aa(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_access_attempts: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8fda195786fefae2bd77bd655869de1891d8c007382c2613b4c747ec31d0f2c(
    severity: _aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemSeverity,
    category: typing.Optional[_aws_cdk_aws_cloudwatch_actions_ceddda9d.OpsItemCategory] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3610dca69ddae6cedb06be1dc707427ee111ce931f9e662a2ba679fb7ec0af7b(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2fe3f47d612779158e450e8df217cec4d747cb79ff3e8449b6cb16f70db9a44c(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd1e631f010e81728e322991e30714f576316075992cad9f8fc1148f4ba3832e(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf5fc5cedaba9e2572914b5168e11bde28e6f730c9ee5cb0bdb27d2f6d0d85a5(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4be668496dcd363e865296a3783c20f706dcaa4eab2db216347b3c5785712002(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb2615482f6aaaffb7055d5c1c46314d31caa045f98d49c8fd50804f738a98dd(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4fb87d3a7e3b5ece036e653c2fb9558d43ee99c0d9f464521b7f4c6642f2d172(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0378c3527a01f7fd49284a42b8daf12733e01204fa288a846a1cbb8d50c223b(
    metric_factory: MetricFactory,
    *,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab560729798f84db3b95041118dd4a433aa9f9ae2b104ea11db142deb50b1452(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7bbba1d3a4b28f5dd027f879085a71a1607012edee0dc89f5a08793138cb01d2(
    scope: MonitoringScope,
    *,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4143dca6c6d54027594284ca458150d17a8ae0ca3c973ad8abb7a97141350215(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86cbedfd44483a9ff3c33ea1c21435c6fcf6adeea3135a751d586749b9167fca(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c1b0995fe263c3c350a9074b0736952f913c59278506136a784aefe7ef02be2(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1280b2f346c922ed3a716b059c1bc7b636ee4051325ff957798e14e5b394595b(
    metric_factory: MetricFactory,
    *,
    instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53f6ed947bb2da80961b319b8b25dd6792c4ba419ffb0ee7a511383e47930c86(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e464b13caa903c703173ec6f96ac13dc968e11dd34f3869d1814906d3fb2eabb(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__caf9403cc98950c23a7dc94c7a5d8be8be4ea67810756e2610831e3fd9e52c32(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa3ba27a2df4940defefb8d1848b3d89eb9cfb573657dde7e4630390d01d4116(
    scope: MonitoringScope,
    *,
    instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76ba205cb9719c80e6579a6883ef77995813bfc9694d8448e75e3f4468ce0267(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__65c37ff8fe077720eff47b5d6e1762a5686b2670fac2af107c58bc11e0e1672a(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eaad3c626963c692a464765dd76b596818bca9059c9e8a54a6c8d6398c2dca17(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7182322cc8a79ca5194e326a200e2540bdf8f40a890e18790608e2be8b421b1(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_records_failed_threshold: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b3f01ba850bece07559600720099f762fd6040516923fea535c3d09e3a68752(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_records_throttled_threshold: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b387c2982450663260be582b01c1cb8c775e8927c02b9cf22abac1b502c19a38(
    metric_factory: MetricFactory,
    *,
    cluster_identifier: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9107c196ac9343509ccba301127e0768c4a45251cbbcbb4eff9199dbcbeea1b(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster_identifier: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de9377c4a8cd037f51e3426910d2cd79ca19b26e7108aedefcc7c032fe8dbfff(
    scope: MonitoringScope,
    *,
    cluster_identifier: builtins.str,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__94ae75930b4b2ac3eac5d4296fcb43c7ee36e288701a0b663bf2f8467093a010(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bfde043368b124871e2c1c8f72410366045b89c2909a849b000e85f704f7d006(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ca63050b6bad8765d8c4c4892f23ac2046af2c5339ba91e1524a72a5dd1ecd0(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d653ab58379bc849d25c1c7a3b105bafc709597df0c39ce25d309d69d7fe6a8a(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__33f45b92ebd4aa5174f3799869ade74a51c13e59f4e0d0751226194d8a84ee92(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f65720457606681702580e4a6f60fcbd81bb9e29adbd66849909d7622287cb3(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    alarm_scope: _constructs_77d1e7e8.Construct,
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cc987685893d9e275ef0330957eb1f56d8338d48c85bbed40c12d369c7a8d25(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_running_tasks: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a4ac8e8c53344ab2dfa21d730313dc804c63e07bfdf1d3b6cebe2ba61ba23987(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_running_task_rate: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__096cb2fb4e2f6e7dac06f84f2b2f940d3303e46503ef5e95153938944b1467a2(
    metric_factory: MetricFactory,
    *,
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    storage_type: typing.Optional[StorageType] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e582b02ed9a6ccef5784b86a08b0cbf5506f440cd60f39a4e381934576fa4d27(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    storage_type: typing.Optional[StorageType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3d89b45e13082029f0f87160a569e5b10198f3a435d9b471e123370013adfd3(
    scope: MonitoringScope,
    *,
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    storage_type: typing.Optional[StorageType] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3bc814298a996859d4783ab8d9fa76f017185a7b799a1965d82c302dee6ad4d0(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b7538cb0f8757fb8399d17c84ebf4d99691cdee82fa77a7bd7c554f818f8753(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c92e63e420d6ae22bd2e4749342e8f02da1c41e38aa913269947f2fea2ca2d13(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6bb7052cf9da993a0104898702cc0dc914243f3b9f0dc3b207f9cd7dc2f84412(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__616aa6f623191f3c8aca599c3127dd0449f96d3c05116441e98a0095673d4c51(
    metric_factory: MetricFactory,
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0b4182cc15b560548257bc4a3a38f08ba4c851ee271ac7fcce6124c8bd99174(
    scope: MonitoringScope,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f5f3471cd35949a7eb3e39e43bc7c1258a0495377758359c6c4a19caab6fd6e(
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6627b909164cade742b8cc3c44376243424d9ff4198741d4f0aab62c3070e3c6(
    scope: MonitoringScope,
    *,
    add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7ed91bf700255a73268dd866b48d73a39d8b317f88c369be4a1715e0bbd518ec(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e75baabd3f5df4747ee045e1d9d446789fed0b7c51649d1f867f6fdfe6fb1264(
    metric_factory: MetricFactory,
    *,
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9179934fd0d9fcf372fb3ecb13c5dd468a0f9b89755959cb3dd13e02cb798460(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a19be3068017849af5a32a8b10b17cdd71d10300ed227884c66d2eb565e1bc7d(
    scope: MonitoringScope,
    *,
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
    add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    show_last_rotation_widget: typing.Optional[builtins.bool] = None,
    use_publisher: typing.Optional[IPublisherConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d72bf22c52f04fd226d58000182c7e1cc0ffaace8ad51a30f291b9867034aa68(
    *,
    height: jsii.Number,
    left_axis: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.YAxisProps, typing.Dict[builtins.str, typing.Any]],
    left_metrics: typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IMetric],
    width: jsii.Number,
    left_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.HorizontalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
    title: typing.Optional[builtins.str] = None,
    vertical_annotations: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.VerticalAnnotation, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8e0eb186116c26e720fe3990d6b02393d658c0ebb7b269c251f984e195974e7c(
    widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    dashboards_to_include: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5c89d9eb9012fc2240c58612071e610bec40747ed027ec64c296ce8a6ef7341(
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8f1f03ee91dbc151a3ddfd104145330525b1bf4c76e01c5ee96c6dc977340ca7(
    *,
    on_alarm_topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
    on_insufficient_data_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    on_ok_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f08a0a9ffa034de35220c631b72c223320fb3c080acb01aba1d39dc24d7b88d8(
    metric_factory: MetricFactory,
    *,
    topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08afa0fabdd34684d04c57f06039a22782ecb203fcb149e4ed216df1bf1708d8(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9cb096ad11a88f652e67ffd68df01d2b133aafd9ae3abc4f794ee93b644d75d5(
    scope: MonitoringScope,
    *,
    topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
    add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f65032f905eb5f3b762a60bd3d13acf1ef2c3433a0f25aeb5b403d81bceda38(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2a3bf0754fecf9935ad74ac425f0abc7a072edc195f2c351b0a5d3f03f4dc25(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3696704314d733e185331a410e0a61b064ecfe00cf672d49f4a9973061f2d7d7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d6281f46ce13fc94b35446126deeaba6953f71d44f38b85e54818a62eea29b21(
    metric_factory: MetricFactory,
    *,
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d216c2df4b399ede82a7d8409225a5fe851553340d92ccb2b3918fc83687a2c3(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58c846089f933e52c75be62f3c8bbcb4f22fa03c3c4237313f94fd7be3c4faa7(
    scope: MonitoringScope,
    props: typing.Union[SqsQueueMonitoringProps, typing.Dict[builtins.str, typing.Any]],
    invoked_from_super: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a5fc521ee6edc97cd2d956c5fadcfe72a420626fa7142ed063233a52ceaf619(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3030932814989949b83801008bfb8758901515fa3703bf279856c55d131de38e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61893c096f81543db130a3057878222795671e8920594175dfffa8a794b9697e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2d37f896e6a3fd47f74c396b511fd67ed8beba7f012692294f4c77ead6ce4e9(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__067bcaeca31d0d01f00867ceeedc3a86d737e904790b316fe4c68e03c41fda62(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5010cb483880c36ba0eeb0cda51e487a14bef7793bec189c748f4756d331ac2f(
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4766b7345cc8076998016b3b5087b826d6622a573592646eb4b25602c81d13e(
    scope: MonitoringScope,
    *,
    dead_letter_queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    add_dead_letter_queue_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9aa7db1138892fed7d47e6e20c69b9c0c7a523850f36e1b88700b1233eb3ca90(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__011bc897e9dd91c2937b726e63a3c133d976755c0d93b329c63dd9c31633be67(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__66bc9c402ad7ecda78356299ba29f715ae0ffd9e3f259f3d77dff9b1da309eed(
    props: IDashboardFactoryProps,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2d52640dc60ef9455eaee64501cab4364f0346f2966724c047e53bcd77e3d35a(
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49edc223731d32ecc673008aab76a1b75fe71db9b0779ed8aee2aa94789f4b2d(
    metric_factory: MetricFactory,
    *,
    activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e4262e5aa7a43e4394ac3a1a696f71c6014b33f65d4428b66a51f7d81994bd9(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__22e3bf314eb4d982c463d555b038f5e4b71f5e5f37b9ff377f59e15532cce08f(
    scope: MonitoringScope,
    *,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_activities_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12c9cbd58de35f7d231f6e667cb541abfc04fd9118829d3de8094f16eda9715e(
    metric_factory: MetricFactory,
    *,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45d5ea61a173a96c99137e9a83f5e16951f61d4ff3f187f441c7beb88d26fd25(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9980c7315140c32287dc9bd4eafb9faad958c911ac8a6d5b6529ebe4f3a478d(
    scope: MonitoringScope,
    *,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_functions_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__95ee9fc0578bba779f0e18b19ba8a8a604beb5152b8d68e44b5eba0885858357(
    metric_factory: MetricFactory,
    *,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2124dbb548f355f7952cb56fe99dac2cae37343114bc8851178d0cd982d61d21(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1f444743ec032fdacb32bfb44fc74b3059c1ba22ee1cbce13b270a53d973ebe(
    scope: MonitoringScope,
    *,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8cf99ac9c0bd4222fd3fd4a789569fb102166bde7437894b6a2767865c00acf7(
    metric_factory: MetricFactory,
    *,
    service_integration_resource_arn: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67a3dd5e4afad287ab31ecd31da343f5dcc0fd70c6352f99ab9afd000113fbdd(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    service_integration_resource_arn: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e6a26a70865e4887eeb737095558ac8d8c769d2fbe156f9e37948e857f208f3(
    scope: MonitoringScope,
    *,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_service_integrations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    service_integration_resource_arn: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f83a831814f419f0eaa70054e62e47bf6a5696874c2ea319b169366ad94f3291(
    metric_factory: MetricFactory,
    *,
    canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ee0704c81a58fffb63613f59492fe7f33dc1f6f99b4d2c55e1170f409ae56014(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce0c24f90bbc5a2e23383abf2a097520c92a4992d21bfdc5e4ea2eca1b51526c(
    scope: MonitoringScope,
    *,
    canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cede60cdf9327d0e34d1f11cc818d9920c5300cad19e5239dbc8c9869fe61abc(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19a8bc43afad7b2c64ace564c28500680e7cfb9a4ffea72c48fdd830fe8e400e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c87bdac6016ca10915835e44da0513eec54cf29cb4cddb6e6bdfa591b858f20(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8abc53b479ea1ce3fd1bd796a1572f64c5fe5ac8555cb703ff385f3a092adbd(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__70242af415cd005ce07c69f3db252cb91b7eefd7b43edbdfc0203045ce2fb9f2(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[AvailabilityThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ec3ad2da6c605cc286e896456fb5d7d40b3c4edc4aa6cda485637ac3e2ab416(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92087bd36fc157e2e3cfc3be729a78c6c98b0255dd27b4cf9b9761e565478481(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0df622c2b17d3fbd9a7c688744aefa5cb984dc2ae08ee8431c13859a28592342(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9f9933456ae353bac0b6521489b3d18def7a5a38f7c56f74adf0644034bf4afb(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e722af6a58321750df864976f87117022091fc84264aef3b506d92387c402ce8(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec222d3d9c17a3075ff4e84028ef924258958cf5279ea15088be678c6c36c74d(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__600be463be20882979f64fe4491211b0ad7e763e45ca042482a011503fc3c6f6(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_throttled_events_threshold: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa708301faa16e8f282b560afc526ec8613e86dab97a3148d8231ac195f1bb26(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__294291652d3e6afa7254c53602461adb08859cfb9af6e2fb799a266c2761735f(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cf1c912c1cfecf9d0c46dbd6c4aa0d09ae4391c962a37ebffac1924ae65ebd7(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__333ac4e95737b1b3223a0874287a7cbe1f32418261e3b87a611bcd7666d1e3b5(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0927b08d6781860c82f33aabd327e8385a811bdc45dbb4406a8fdba19f59142(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__27b890b7f9c561584239aef09437ef2049e1d751cc47ef1fded39c1a786a8773(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9701eaaf292ea329990ee38531c3291c3e7fbe5d5f36323134c193bd9ac9b13d(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84b2360f69539ac7bb6a6d68748f4e1f18500bdd71fb1a3cc7f0fa37f5261a7a(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a24fe3364597b00efb14bf4983d4065532826e7b0b700f908b7049bc95e5022(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e61208c7f53894f9ee47dc958f49741d8dd5345dd6ebfba8e4b29d1b4416201e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_unhealthy_tasks: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6024c89aa647570c2d472db05673d44c0185218b92a76118d2e35da2e546cc58(
    alarm_factory: AlarmFactory,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__456af966814b00fa77d8603b83ed545f2565841a9aa89993943cdc90339dc73e(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__994aad6de5d7f078d766fc2755e206840482d4e8bebb5fdd28c6b3d7fbd32e64(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
    usage_type: typing.Optional[UsageType] = None,
    additional_alarm_name_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b368ff0d337f1d428df2b41fa943b4c723a47f6d2f649273bfdd84ca0d24257(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25287e087b4a879261e5de282f2b9718bd0ca38d97f153236f47619d18bfd5bd(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d9f998f94e5c5a53b2edfd13e376a5677454ebf0374dec19169eb51abc6465a(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__287b250c67bf52f1eee63e27ac669c68cba0c3ffe49bbe045e0ba80e0dabebe1(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__685cb74f7702a8fd45d2866542bb0dece98587c28e475b20bbd0d6269b90545b(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7b8af26b836c7f4d9bf0ced99829735b3ebbe68dc46272b876a356d922aafc9(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f7096d8940ef584f4ec97b5eb157b99dde6d685326c56d1c1fbd200beac086a(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa8162cb03b135be07bbd84a562567b7a8e2c20bd2af5c9fceb33323ad5b1852(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74974b917d51926e118b2ad2d5cfe13d0cd5f0dcc7a87a6c8b13ed595ddfbc40(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]],
    usage_type: UsageType,
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9375a9c28084134036902936452f624af94a5bbf037f469581b283365a77db5c(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4500d9b03bc8c08fe2815b3f58023c9cb2c226a893bb816990e629a71d814dd5(
    percent_metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    props: typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]],
    disambiguator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__945929fe315cbfa9072390f81c1eda11eea270536d078942376af0620d93c151(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_usage_count: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__062bb0fb889d69b2a6dd92c73e9d906466c191caa9c25cd9d8407f2e76339a2e(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_usage_percent: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__840fd490893dca69a0d2f0937cb6370b475f368b3827e45ea0bcce53f7620aac(
    *,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00b3ae71ef5bb8a55bd6886b3abc9219bcf416aa0759268217a9acec63175f47(
    metric_factory: MetricFactory,
    *,
    acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7dc04f9ab59e328eed1822811e91892bbd63f15c038d7f017032c88e5ed35692(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ffa7d244eb495c4ee5b9ba523d94533cca861a86870c025e1e574e55346e4da(
    scope: MonitoringScope,
    *,
    add_blocked_requests_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_blocked_requests_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__082ce58b14094d5c253b34e1566acc04757c81d4f7bf8d0831d3b051b2ecb406(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30836197905661f1cd2bd7e059ca9e6c296788cad72a9dff64546df895700fa5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34e102fcb99746157acd883e72313acfe264c5173b411edb6c361d8f265b01a5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae44dc3f7f4671f357c2c9abda0ac63738adb722a9c07a401cdd1f0e5cd59b3f(
    *,
    color: typing.Optional[builtins.str] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    search_account: typing.Optional[builtins.str] = None,
    search_region: typing.Optional[builtins.str] = None,
    expression: builtins.str,
    using_metrics: typing.Optional[typing.Mapping[builtins.str, _aws_cdk_aws_cloudwatch_ceddda9d.IMetric]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0ad60ad49086bddfe7d3aa14d36a9ba4494adc2ecc73aa5f0ccfa11ce90206b(
    *,
    action: IAlarmActionStrategy,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    alarm: _aws_cdk_aws_cloudwatch_ceddda9d.AlarmBase,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ff5cb942cbeee514e41e8c557fbdad8dd19936c2ba21c01ba16dec78592fb6f(
    *,
    action: IAlarmActionStrategy,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    alarm: _aws_cdk_aws_cloudwatch_ceddda9d.Alarm,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    datapoints_to_alarm: jsii.Number,
    evaluation_periods: jsii.Number,
    fill_alarm_range: builtins.bool,
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    threshold: jsii.Number,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf95e8544d24099bb0e42c2f5f4ec3fa3be5861dcac0ec558abf083ee3bdf246(
    global_prefix: builtins.str,
    local_prefix: builtins.str,
    dedupe_string_strategy: typing.Optional[IAlarmDedupeStringProcessor] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11d6898c3b5506203798a7f791daee2a4e439473de0a41e20655d181febd012a(
    parts: typing.Sequence[builtins.str],
    separator: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e24e91b81fc2fa966218c11a02883b1bcbd8696036153b3d0c6166470c03df4(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    alarm_when_above_the_band: builtins.bool,
    alarm_when_below_the_band: builtins.bool,
    standard_deviation_for_alarm: jsii.Number,
    additional_description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9265647c98954edacf49deb7db52bee562d8a481ca25c2973388e59c3656d990(
    metric_factory: MetricFactory,
    *,
    api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2933aca068332399ea22458abe47d58325c3bf76dca46e878ecee73de9b39457(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1b780ea37d9219999048c1925625d47526eb003c3a69d33b0eab72fa5e80b83(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b720f596ff947157946fe1844ea9a4656c6771c11d7a5c1ad15e9f018eea59b(
    scope: MonitoringScope,
    *,
    api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efb13f07afe862abea652b153d56ecbcd1eb6c9935d1935343933ba601d331fe(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d527ebe02a354f1c53b3878152be184b23cfc45ec0f4589f60d9e26ce58c383(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0da843726b9d0590b43acae39901d875d48cdcd99c4476fdb0ef3b972ff8ffd6(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cd1d3a0a2556be4a12fc62dd3dfb2b889af0a7caa8cb7983b24b058aa4450cc(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__333c3dc19812d29c6d1cdef356d6ceb57a9e346541de40c4f033ea4a082739a3(
    metric_factory: MetricFactory,
    *,
    api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__03e90424371df13e94c607f00667057762246bfc1bfdf54b3e722b4cfc5839df(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c8b8e7278a676237b3a273a2a865d3b6efef4974a9fe40e30b2cf98a27c49217(
    latency_type: LatencyType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07a14cbee36ab23e9614418680d401aa63088f40bcfb6664ea37283c5671f2b8(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d0f379c068fa5a7227fdd5ce89fcddb3de5c2bc03d8b3d9d92525bca958a1c6d(
    scope: MonitoringScope,
    *,
    api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__814dbd0e59b28a8ba31ef49112b2adf2cdc47b5782db632cc43033b145c3b72f(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6abff86504e2f01d193cd82baddbcffa8f837d7276e28e86ba014b104360577(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ceae0f5e532726995d49835b07bb976393fa7d8cdddea5e281500b59f6402f8(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__674420fbad9bbb8844a16ca12cd65af8559421cd53b4ed77e34fc29b29c0ef56(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__844568eb480ed5add96a514f3f3406ba540b24afc110ececdddf2622cce93398(
    metric_factory: MetricFactory,
    *,
    api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3a9865c80c4bcd1d83aeabfe926ada4cdd9d8bf53b72e8a30457a25aac75fc1e(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1daa967362dec41e8ebe95e6b5b774e7b59c8176d05369f509ba760460778634(
    scope: MonitoringScope,
    *,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b724e8e62bcd6e7b334a91acc881dd5d9a9c9dc7682a69b26c4c3e9bb5ff6785(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__045ec8c570f1cfc4c02943856129d3c9cd01daf12755ed830af5070044c8b354(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e80198ad898c199cd24e611449241fa11af413007581cf50ecfdf91da799885b(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a8208dc21f2b1b65649074b8c4b4d555f7178a39d5b3795e2160438099a3ec8(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb24f9c84d04f099fdf8ff84601bffb14256c8f67e7756029d0dd6553783bd4d(
    metric_factory: MetricFactory,
    *,
    application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
    application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__81e225d547c4cbfc767f806ecf23670cc87eac8536e93d8d47f47b0b1935b130(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
    application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__827d9809fc95b8a73f5140a9e92cbdd7b7fd3c080554c6a94237a91e94a279b3(
    scope: MonitoringScope,
    *,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__266fcd0566054f108e9afd65962831628ec1f5fa16a14283b07760f0227cc952(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5d0bc3de6b25850b4fe616d66af593aa2dd4612468467c1aa91f4f9249e18fd7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5377087ea88eadf7f740a02af832c5e9208c5bc930b74bbb42d99254da0b407(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29ce2f185a8fdc1d51c8d62502386d2f9066ba4ec5d979554d155b15ad38e5d7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfe1dd21cdc435fdb6501dbf50a5d3ce644af96c807d6540ef3c9b7460b7e907(
    metric_factory: MetricFactory,
    *,
    auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6de94510d05777fe13784d3f29b279afbd23e8dac87707d30b6dfc7bcd265b91(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dbcd9a2f4a12ab57b4d43340f7afc767f9248c9e5d6c588593e2c7e5d4078d81(
    scope: MonitoringScope,
    *,
    auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5cc9f93db7f5add5437e8783ff7785b884f5579b3a34bfe0f2f0b713976d417f(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__55eda2fc0ab5e696fcf442f73d0962a742c77d9cb4bb79dbd34e9e40958c7fbb(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c47c4f9e17b67f8834271d18ac66c2e5498f510c909162acbd8ef7384251b7e6(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    min_availability_percent: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__303226e0420ed80925da8d7af82a367ce5ccd439752d8aaf9906e4f002b15c9b(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__985ea9c05f237a4369b5828be0f4965445d030b817d4a05e8015388775a3affb(
    scope: MonitoringScope,
    *,
    add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3959073f1e77b85827a201ad89dac47915a28582551e766d18229b2fb7b5c941(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dff748e83a4a9ba43c4e568de12567756547489b1d24a2d2916151b7a61d133a(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2752b920af7fb2759b1023d4f6b301e2bc5d38f13401be5961e1b90a3cc62d90(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__794989ebcffbe030f2e43475b79d9492867c86ad64798762444ec6fc98262adc(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_total_cost_anomaly_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[AnomalyDetectionThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f8a717a0a53d58c17d1860989333cf65b6c91a2c20bc392e88d13f9cf17921cb(
    scope: MonitoringScope,
    *,
    add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__250fa9e11c63a3934ffb8d1cf29937590d3e75474c9341d04f87d26f4837e28a(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c529c8080c5dd5316272113f396ef6283604a9c4773c26080229ce8c42b3ae58(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6093e537fe2b41f8d4f6d88473fc4b146981d120599da6daeabb9ae01dd1bc76(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_days_to_expiry_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysToExpiryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7ea4eb337e6e22cef130bc0fdb5254f12875a9ae1c3badfdc3e940666fdf265(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    alarm_when_decreased: builtins.bool,
    alarm_when_increased: builtins.bool,
    required_secret_count: jsii.Number,
    additional_description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e4a1cace39c4f29b3ffff6df734021951a5557ead750cc45dc667dc1814be4fd(
    scope: MonitoringScope,
    *,
    add_error4xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault5xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
    additional_metrics_enabled: typing.Optional[builtins.bool] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3538163c09f71f41f7f3a83ca030ea3e765088f8b81d8e9a6d59bf30ce09ac2(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e5a32df588d667549a1c706078ed3a6d566065103ce696037bf1e82e28093f3(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__31bc1b110de542f42806a087ff78785a3d84609526ed25685c15a471776e2aef(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4635e763010715810de04942073a8f54f17e2bc47243202cfd42bc10a95aaacd(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b443aecb88d3818b62896f301695762430be3bf642f8a6e018f6182db7f65a99(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45c74d34521086d3585e9bf5a5b44c8b96832aec2f929e658b1d414379e52243(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    distribution: _aws_cdk_aws_cloudfront_ceddda9d.IDistribution,
    additional_metrics_enabled: typing.Optional[builtins.bool] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_error4xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault5xx_rate: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46f1966bec5615f9d2bfd95742a862ee5da4daf12ef093baae65df5553ae47c2(
    scope: MonitoringScope,
    *,
    project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a4f043f3ddfb69c3db9e2e8fc16e723493828edb8601744953acda4dce58c05e(
    project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2fd55f7b2b9c31e08c7c6691646786d3542f87367c775d8732c024373353074f(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e43f054c9d2d210bd968323d04aedfa07215cbe443e2eee42288175e213dd427(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    project: _aws_cdk_aws_codebuild_ceddda9d.IProject,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_build_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9fd10824b90eddb252f36fe8d33ca71f8233426110eee5cfc51d6c232cc8a6c0(
    adjusters: typing.Sequence[IMetricAdjuster],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85a4fae865ca71e7ef4371e7f98b9831bb5f55e9f840da1e2dd730d9085bbf83(
    *adjusters: IMetricAdjuster,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48e87691740111817f57dd8be791059a5947a45df5e0f3bc8af5ba949d2a542e(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    alarm_scope: _constructs_77d1e7e8.Construct,
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__950df7879b973387d492483d4d3727cc319ff16796edff3c18145fac0afe46b0(
    *,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    comparison_operator_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
    treat_missing_data_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData] = None,
    max_consumed_capacity_units: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a304626361860e6052d9dfb4a3f62116e2ded9276e6660ec72b9b9b60e5e0abb(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ec2_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
    target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca148996f7cf647fe69caf41a893806d1dde924d66daedd882dbf8ad4004aaa4(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    fargate_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
    target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb6901613ed4d317d1376c856406d320c178d064742c7c03d53ae434d9a53a80(
    scope: MonitoringScope,
    *,
    metric_groups: typing.Sequence[typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]]],
    description: typing.Optional[builtins.str] = None,
    description_widget_height: typing.Optional[jsii.Number] = None,
    height: typing.Optional[jsii.Number] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34981c330536725daac1b224ffb995800483868db8f6c76aee1c38ee2dbac848(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    metric_groups: typing.Sequence[typing.Union[CustomMetricGroup, typing.Dict[builtins.str, typing.Any]]],
    description: typing.Optional[builtins.str] = None,
    description_widget_height: typing.Optional[jsii.Number] = None,
    height: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a7da71f0777f8bc55169f8588a8908fe7713005945fa342531e6ca22b135857(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    dashboard_name_prefix: builtins.str,
    create_alarm_dashboard: typing.Optional[builtins.bool] = None,
    create_dashboard: typing.Optional[builtins.bool] = None,
    create_summary_dashboard: typing.Optional[builtins.bool] = None,
    detail_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    detail_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    rendering_preference: typing.Optional[DashboardRenderingPreference] = None,
    summary_dashboard_period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    summary_dashboard_range: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__567a33262c9610e38349af9ccacb33edf7e26b136711f9a102f2c15da7bd701b(
    segment: IDynamicDashboardSegment,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ce41a9d218dc88cc03af8fff60a47c505172785362dfde6b048ab496df577ab(
    props: IDashboardFactoryProps,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e62bb0f28f588b4411f45a58716e45012b165bcbfef46d9e8dc4d08e4128f1da(
    rendering_preference: DashboardRenderingPreference,
    id: builtins.str,
    *,
    dashboard_name: typing.Optional[builtins.str] = None,
    default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    end: typing.Optional[builtins.str] = None,
    period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    start: typing.Optional[builtins.str] = None,
    variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
    widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__24cf41e334fc53d3f876a745193eb55210100ca2f5334512e60d698413149183(
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c48f2a5fd9c390758999ac1b50190054bbfe7413aaeeeb8f2645d38242ecbeb3(
    metric: typing.Union[_aws_cdk_aws_cloudwatch_ceddda9d.Metric, _aws_cdk_aws_cloudwatch_ceddda9d.MathExpression],
    _: _constructs_77d1e7e8.Construct,
    *,
    alarm_description: builtins.str,
    alarm_name_suffix: builtins.str,
    comparison_operator: _aws_cdk_aws_cloudwatch_ceddda9d.ComparisonOperator,
    threshold: jsii.Number,
    treat_missing_data: _aws_cdk_aws_cloudwatch_ceddda9d.TreatMissingData,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    datapoints_to_alarm: typing.Optional[jsii.Number] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    disambiguator: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    evaluate_low_sample_count_percentile: typing.Optional[builtins.bool] = None,
    evaluation_periods: typing.Optional[jsii.Number] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    metric_adjuster: typing.Optional[IMetricAdjuster] = None,
    min_metric_samples_to_alarm: typing.Optional[jsii.Number] = None,
    min_sample_count_to_evaluate_datapoint: typing.Optional[jsii.Number] = None,
    override_annotation_color: typing.Optional[builtins.str] = None,
    override_annotation_label: typing.Optional[builtins.str] = None,
    override_annotation_visibility: typing.Optional[builtins.bool] = None,
    period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    runbook_link: typing.Optional[builtins.str] = None,
    sample_count_metric_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1e88e4f36ea1e7b66a8daefacf2fb97dc7886edecbe71599c6c6c8eee077021(
    scope: MonitoringScope,
    *,
    cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__98acd3af858124086fbf09683321a61ffb023b09963e2b84fc5a1a98b76bf006(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6060f9240007102ddcfefb66091157ccbbb11b7bec5e93f4507a2d4e01651f8(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7b858d160ab88e517ff5eed0af5b6a55fa19eae6a3e5e4d80530d09aaf7cfdb7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b654642762c1748e55f5171b47b089c3b2bed62fe06c7082929bb45f87af460(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7c52457e6fd71c3f03a296fc85591a202914a350f19b63930e9042b2cbc90132(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b24b5c45366956ac2a02dc6668886aa14a662de443690fd1b7f5b43e84c2ef83(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster: _aws_cdk_aws_docdb_ceddda9d.IDatabaseCluster,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b500f3cc5c40638ab2379baaea64735ddc3f97a08ee1e394580c5a07f6abd325(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    dashboard_configs: typing.Sequence[typing.Union[DynamicDashboardConfiguration, typing.Dict[builtins.str, typing.Any]]],
    dashboard_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48317c1c565aba9d39738b52c4a7783f0731f90098223c6811b332d68caaa03b(
    segment: IDynamicDashboardSegment,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5be96cb7dfe8f1ad920be8bbfc56df1517938d77480eb705bfe8a35e19ae5197(
    rendering_preference: DashboardRenderingPreference,
    id: builtins.str,
    *,
    dashboard_name: typing.Optional[builtins.str] = None,
    default_interval: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    end: typing.Optional[builtins.str] = None,
    period_override: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.PeriodOverride] = None,
    start: typing.Optional[builtins.str] = None,
    variables: typing.Optional[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IVariable]] = None,
    widgets: typing.Optional[typing.Sequence[typing.Sequence[_aws_cdk_aws_cloudwatch_ceddda9d.IWidget]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a1487ec2398f4957e8c383fa4d7c98499be2bba7c7294dadc8e5b20c429c543(
    type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf171c6831d16b065d161f0dc47fe17d5206b9a08de37d274a06b6293dc37dbf(
    scope: MonitoringScope,
    *,
    add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    global_secondary_index_name: builtins.str,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__101b7b6cebedbf3da6992804ccb081e45e07e026888d94476f565de837a47bac(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e20e8602f5e934026404de3530b5da57acd4f65e717ccf4385991a49b1eaa8e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__641eec8247d6802cbf1102f0f35eae85ac26f2ba70737ebb352e22ca9d4624a8(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ee86a5699e86385225c4d433f3a0288275b70a23be96e2e660435973f77e25c(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    global_secondary_index_name: builtins.str,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca296110c2e29e52184e6066df2f88917a844b14e1db76d6b21baa01f993de9c(
    scope: MonitoringScope,
    *,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
    add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ac1780f164da0e5bf393be145310d5cbc8e5c5152fe6d4d495ae66edae7cefb6(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f976d265ab30e5f98d88f2916e88326f387c47b194f8475cf8f7b627bd93ed4e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5b9a403c596c812f203b5dd92327182806e69937795789d62ebcddd3e2f726d0(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48ed1306b832ef6248189726513e3cf36f3d485d8a84a40c0e76f1ef62f32a45(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7e96c371880b8d3767c028eb5123e7bbe5f75711df28fec58bc169851365b42(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__88ff626ba268b68176d1c727f30e4bfdeac33b29530324acddd70fd2d9a74595(
    operation: _aws_cdk_aws_dynamodb_ceddda9d.Operation,
    alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb159b396feffebf1b7829b15c1b2264dc6ed9389a5a1644d19296e3f60de944(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49700202abdedb811650d2ad77a26e8bdce4a39c9a97e0298976d8e057a0ff51(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    table: _aws_cdk_aws_dynamodb_ceddda9d.ITable,
    billing_mode: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.BillingMode] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_average_successful_batch_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_batch_write_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_delete_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_get_records_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_put_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_query_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_scan_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_successful_update_item_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_read_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_consumed_write_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ConsumedCapacityThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_time_to_live_deleted_item_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_system_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_throttled_events_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ThrottledEventsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9044560fc291196c2f3f049a458125431528e7d078d4afe65ced354168813c22(
    scope: MonitoringScope,
    *,
    auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
    instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1203c8a9a5145b1937fdb9b958dc702828c61bf030917c7b75d0f7238f4bc73(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b9145251a3cc982a238b788c37ee02485427ccfc4d3a3c1afa4d094d2bb0d399(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__413815ba080f1de4f37738ddff41176478a39a267cc73a4ec549533e13b28a4d(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2f2dceb070988be0b6142ebddf7801f6db293b4adaa23ca4a3c1ad5cf755623(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0184606d6c3010e92399005956d361106afd5f90cd5bf12b900554ee875664f5(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
    instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__858c0d13aa43c10ef51db716a9b96ffed8af35614d16d917d50be61ffa5469a9(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    auto_scaling_group: typing.Optional[_aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup] = None,
    instance_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__632219ed38efb376e5f5e7c65d328884c8ec2d4dc5caae29b003d62117d2b39d(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
    application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cfa00e8d209ffb05b37dc20b1dcb3518d9e879b995d834b51fafcf22750ea6d(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad343fffff4cc79130a4ea22a3f3866c4c1cc64a5e4cb04f14b0d92d6952388f(
    scope: MonitoringScope,
    *,
    ec2_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
    target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6803498f214d1b09005eb86a5df825f4c93ccbaded6cd9a18738b14a9213ed91(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__abfb1e74912bc7316618942fd082a2b6e8a17e3419b4c7749c23fb006d0a1cd1(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff6d0f1f3b4983d42f00be6665cc2fa8f913726e15ed2dea216448429c0ad9f1(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0fc83651f96213ba15c624e7b185ae834aa40c940655a8dfbf57ad83c509092b(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b8a9b872e1c76861f8eb0b70375c97d3116290faf83d491793b8b253642df70(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de28af7d1d92899f2f98108192667cdca5e74943e210891771f0cc037f39bece(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ec2_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedEc2Service, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedEc2Service],
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5242bec0be6d9e8f17f1bc52457d694368307f7b0278a492167968690c3191c(
    scope: MonitoringScope,
    *,
    cluster_id: typing.Optional[builtins.str] = None,
    cluster_type: ElastiCacheClusterType,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1cdb70015a9d7c70692e9c51dd42163190aaf55339f09465b3e91a1fce91d9f5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b709041e73dfed8e3e5be477e2ddf1f170a5f54f846a9594ca52cadcca795a18(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39da7f042e2f5484f8c202edfc458e0b6bcd6ac1697fbb4f0ac900e94b197918(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f325ee204e22331502b5240c59a5b331b753e5289df5f7efb56c41eeeff1dfa0(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5c853e318f7720d551e3d80ffa10219defbcf199968e02b10d716fc70c9a9282(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfbd4e29efaf5b043591a9a84030fe155e21b5d5c6f02bc54c9f70ea1227c8c5(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    cluster_type: ElastiCacheClusterType,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f815c53c9536f7ee998167d2fc7c73449d61c3d85b8f6439555d540e5ed9f91(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster_id: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    cluster_type: ElastiCacheClusterType,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_evicted_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_items_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxItemsCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_used_swap_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsedSwapMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_freeable_memory_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinFreeableMemoryThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_redis_engine_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__503cb2d7fecf37d79e0e391064880a51e83b28fa6a5cc83dd22615ea7abe8753(
    prefix: typing.Optional[builtins.str] = None,
    suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b004d96b7986782b01647f31857f1f29474db5ba57d6592d9c439517f91f464d(
    dedupe_string: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84caa32355b3aea9ba7415e2dc0b420c4f6b6907c04efb4d65a28696cdba7f2d(
    dedupe_string: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb2989da27c15f643e02a55c18e814ae8000f0dc46c81c4c965ba97915aee107(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    application_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer,
    application_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9f8c5228a815ec10ec36ed64111406948e5fc9e7bb1f17303e17877f1ea0f185(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f9328f631880ce247f60e2e6a197fd139b3de4938d0ef96d0255e0363790b725(
    scope: MonitoringScope,
    *,
    fargate_service: _aws_cdk_aws_ecs_ceddda9d.IBaseService,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
    load_balancer: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationLoadBalancer, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer]] = None,
    target_group: typing.Optional[typing.Union[_aws_cdk_aws_elasticloadbalancingv2_ceddda9d.IApplicationTargetGroup, _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup]] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cbc430df27e0ab56b683a9919c3c7f89da1070d99094edec9d462ce805445cb2(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b18db518cc36809964075a36fb691846e5c1f6b9793df537ee170827d0c631f(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42999028838d6f3a4c03901f33eed189d89ea3f0371ba7d93fbf1acd11e03350(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ce55186d97ff139349bad2daa672144ddbb72dfddb9abbcdb20e70ae8c920a7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d414135d2047fe641b5df246bc947fc593dbfd55b0807b6587a043b139b676b(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__70264c750ed57fe982c43247ea46fa41074bdffe16f85e72ef0a343f3f2a22d7(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    fargate_service: typing.Union[_aws_cdk_aws_ecs_patterns_ceddda9d.NetworkLoadBalancedFargateService, _aws_cdk_aws_ecs_patterns_ceddda9d.ApplicationLoadBalancedFargateService],
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    invert_load_balancer_task_count_metrics_statistics: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a628c56b07e7792ecbcabae31115f1b74ec51b35ff7c645568bb65b679e87170(
    scope: MonitoringScope,
    *,
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    create_optional_metric_filters: typing.Optional[builtins.bool] = None,
    namespace: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b19f477d9fddcfe96bc4dd0efc7509bb085f94e0fc202a7fb4d4994b881cbc7b(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    namespace: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    log_group: _aws_cdk_aws_logs_ceddda9d.ILogGroup,
    create_optional_metric_filters: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__22b0f474d6af396419dde83af6e523fcd4a49682d6ca80672e6fe7953f7fdec6(
    scope: MonitoringScope,
    *,
    add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    job_name: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd0a807f9138865ab1ec2bf34e06444f9b935a310caad8ed546fb5474a6c47ab(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__41fae5d326661559ffe0f82198a25b474138fac35c5df7279fcd193389d05bc7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ac2bab02fb4b55d7188ed3e7dcfa2dc91e10cb5a5c845bac06c936116be12fd4(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c1df77e83a37db6e26f77fa046ecdbc2152a4a3dd90aa202ec73abe891e6015(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e863a603953382a8c09680cf582cc5ce04df48c58f19d6046e74415d1329045f(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd9bbe491a1aa388910943cc1423845ad816717802f10d327bf1df10d645fee7(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    job_name: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__085e1f2eb07133096bad6508941ad5e65f45433816d71580d4ba753f435fa8e4(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    job_name: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_failed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_killed_task_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38a7d1b577cd82fa4c9a2054f49bca41d9f2057d3b6e7a6d3d32c987103744f3(
    scope: MonitoringScope,
    *,
    application: builtins.str,
    add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__635e48cbc71ff5a20252794f78f1c18a14e09a55fb035971572e04ae0a2b6c8e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57ab2336f9d3946acd405fe3b3aee080ca187d98e7fd930df202b24d8bae64c7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1a33824c4aebc05fdedf787039987acfa88e89bcb678fb0489384c757619684(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45f2e91edff5f1c19ec66b859666ed785d6d02bb67185ee03c85ad40769c92d5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__03e959a14341ec179c94521dd1010120f7f06900a496ed19685b36541de419a3(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7731af01a0176130da7f2a4a6decbb0f62cfe6ca20deb2ce36afc5b0d1c4d71e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b45d64eeeffa382742cd9cc3bb17f7f9f8cf8e335b51b07ddb41cc5c39cb9d2e(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0b224cff688f3c07347d6cdc1bb9b45868b12e698039442af904c976a12d345a(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51cb8da315986734fdabf244c79462739bab30bee71cf81f4a8b0161c0f94966(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__75ff1f1c6e14943be636c413fdc1fea473b93121aa20fcc0da022a59914f76ec(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    application: builtins.str,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_downtime_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxDowntimeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_full_restart_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FullRestartCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0dea745df641dddbf9a3ec2331d33999a9e8c4bf55bf22960dee4f411422c20(
    scope: MonitoringScope,
    *,
    stream_name: builtins.str,
    add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__15675bdfea52113be935ed1beaef26b54e7e5d182253a819b09c6d2f5dfbd3b4(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e5942ad4d15da6b8776f9df4c73768d892b15de19824856d742b199a142bb15(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b508ce33db14b1bd73f6b1a17db170b15fcd41a94c9847a75e4dc7de83e7c124(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a4ccac305f273ce99ceff1c575ef5e2ac8793c3a6aea5c42b28aca02dadb51aa(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd33f6aaaf491b0fd170cd6bc587eb49bc5d42283dcc6a0a7ebdb158711a5fa8(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bd11ef78ec316426495da7edada56d1ccc0291d5442d80ff45f8bf1ba3c84bc1(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5344ae1011115612104a1c26097b60bb0b8b1bf3a27b9a1de75ab86cf3250e53(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d416de5c6206b97c3384d0ed8ac710b02485550260739a903556dede7a95062(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25cba1ee4f7ed53338ba97d1b8d2a97ca2dfa0c36613c28201b520938ca6dab6(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    stream_name: builtins.str,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_iterator_max_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIteratorAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_put_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_read_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_records_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_write_provisioned_throughput_exceeded_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__065ad9b14181455cd68f4ec57b6e6fa323b1947106fa92257acbb1364b960bde(
    scope: MonitoringScope,
    *,
    delivery_stream_name: builtins.str,
    add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca36ae3ee4b6407d048dc54c02d4bca984785c7effbe55c9e456d173a9eeedd5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d0a47375abd5091071d99d5b9fdc60e88515a5b25a633144c49e003880824844(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6bcb7b25b6ab028683fdec5a181b9de182fb9a8c0330bae810dc0262b1167e78(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aeaef5bf14c4986829aefe302a614af8deee99eab851bfa9fc9f467a4dec0cf7(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__47ca1db0d356b32d6fb3bf272efed23d37bcc2a0f10a7e7a3891d2801fcbd270(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0fad3079fdd7e7a614d6e6640d09dc2a27dd48aad835bb01d5368ac9d0178c8f(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    delivery_stream_name: builtins.str,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_incoming_bytes_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_put_requests_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_incoming_records_exceed_threshold_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[FirehoseStreamLimitThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_records_throttled_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RecordsThrottledThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12b84d235b139177523803700e7a659a1b35e11854610a7d0fe1cef454da0e64(
    scope: MonitoringScope,
    *,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    lambda_insights_enabled: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    is_iterator: typing.Optional[builtins.bool] = None,
    is_offset_lag: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__66bdff6e38dc362f7604424cf0f646e7e95aef1962ad2696ef69715c9f208718(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__91fa11c48155999cf862cdc68ea2a9ab029bd489c80bbcb8aa10bb7438d16a2b(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b0cd40e878a439afe6ec9b5402342bfc4f03dcf2ce9d9a5811f330bfcbf062a1(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29d896254371de4780c8bef41eeab95f954ce07af3d151e947ed2b22607e6fb3(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__268ade446bcf584fd293487eb0ce7c3f437fcf2cc3350ad06207d3a6949dd7c9(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82141ab86ab8856b3bbdb39e68abfcfaca2e3f807ac39a994dc67c715f137332(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__707cce4c1a38dc181ab4f192e5e343ba8369a3d8bf198febafa5418c27c85ae5(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cc84570eb583f94f0f00be915b90472b4e3d6b003587020520e8d4d70c448f37(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1ceeab89d65ac18063152248973d859e7bc057b2386cd05b4b6d2f87847a216(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a663670c545c7321f11d8f943a6ad49377643e0ac8540b8e5014ba52a6327d3(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__209e79a88961e04f21d8d8eb144c49a1ce8879a0b18068df9a04ec2ec7740680(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d18010941a2fe9b0b270b6130d7129562e7b9987185867d493ca3d179cffe35c(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    is_iterator: typing.Optional[builtins.bool] = None,
    is_offset_lag: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8e65969145bc6a53291f4fa8a76f0fc046e32d4e8056c2f0869c3a84e28b7ee1(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    lambda_insights_enabled: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_concurrent_executions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_avg_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_max_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_cpu_total_time_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_enhanced_monitoring_p90_memory_utilization_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_iterator_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_offset_lag_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxOffsetLagThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_provisioned_concurrency_spillover_invocations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttles_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    is_iterator: typing.Optional[builtins.bool] = None,
    is_offset_lag: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ace7b560e5ce6dc00a079bd030c152359fd0385c6eb9fe63936f6b83d3a0c10e(
    scope: MonitoringScope,
    *,
    add_max_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    limit: typing.Optional[jsii.Number] = None,
    pattern: typing.Optional[builtins.str] = None,
    title: typing.Optional[builtins.str] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    log_group_name: builtins.str,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f05326f15012ef001ce1de9cfd486faad1f75d8618226196b191bf79fe4d1fdc(
    width: jsii.Number,
    height: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca59d462b6bd07f0e0c737d1a0148125d48b3e52841215381f91f463b7697616(
    num_rows: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff0b48c1359f7ca202031bf8bf34ec397a1faaf3f7a823bfd31d9c984af66346(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    log_group_name: builtins.str,
    add_max_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_incoming_logs_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    limit: typing.Optional[jsii.Number] = None,
    pattern: typing.Optional[builtins.str] = None,
    title: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__60d1916429139435d7fa7a12c2a911f24fc1e8211f5a6f85c97b4a2d0712d588(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    alarm_factory_defaults: typing.Optional[typing.Union[AlarmFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
    dashboard_factory: typing.Optional[IDynamicDashboardFactory] = None,
    metric_factory_defaults: typing.Optional[typing.Union[MetricFactoryDefaults, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d211cb96de28b1c67037c9d133a69565bcd21c189f605b301825b2735e67cc26(
    segment: IDynamicDashboardSegment,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9d99dfe696828a7f703f8b8b477e2167b83ccb8497245764d3f0e1d77abf6f4(
    text: builtins.str,
    add_to_summary: typing.Optional[builtins.bool] = None,
    add_to_alarm: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__abf1f7e12ba4c11b5d140f2552de589dc30c79bfbc0ef665e26561dd6020f399(
    text: builtins.str,
    add_to_summary: typing.Optional[builtins.bool] = None,
    add_to_alarm: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e97eb86841d101df2335f36e088d0dbf9eaea1465ac960bc689cca33956a5da8(
    segment: IDashboardSegment,
    *,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1d1f79507132db1a6e5aa48d09fa1c0bc369befa6cfc02df77f86f6e1deaf32f(
    text: builtins.str,
    add_to_summary: typing.Optional[builtins.bool] = None,
    add_to_alarm: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6c19f8fc0852248da01ee21d56ff49c5bca5e9939d7ed5f0bd931aee21f543d2(
    widget: _aws_cdk_aws_cloudwatch_ceddda9d.IWidget,
    add_to_summary: typing.Optional[builtins.bool] = None,
    add_to_alarm: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3a9b47b86692d73d9bf9c4437266c4d331e9b66c18b512bd06ab96aa0d68e00(
    alarm_name_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c56c0d362d0a9bbae754fdd10bfed41d8ca4e5da9c6da62e96bf804c5a86485e(
    alarm_disambiguator: builtins.str,
    *,
    disambiguator: builtins.str,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
    actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    alarm_name_suffix: typing.Optional[builtins.str] = None,
    composite_operator: typing.Optional[CompositeAlarmOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    runbook_link: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__511f45620cd8f0f55343b8add7f7223cace944a651177a3082197c53d0e0fa67(
    custom_tag: builtins.str,
    *,
    disambiguator: builtins.str,
    action_override: typing.Optional[IAlarmActionStrategy] = None,
    actions_enabled: typing.Optional[builtins.bool] = None,
    actions_suppressor: typing.Optional[_aws_cdk_aws_cloudwatch_ceddda9d.IAlarm] = None,
    actions_suppressor_extension_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    actions_suppressor_wait_period: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    alarm_dedupe_string_suffix: typing.Optional[builtins.str] = None,
    alarm_description: typing.Optional[builtins.str] = None,
    alarm_description_override: typing.Optional[builtins.str] = None,
    alarm_name_override: typing.Optional[builtins.str] = None,
    alarm_name_suffix: typing.Optional[builtins.str] = None,
    composite_operator: typing.Optional[CompositeAlarmOperator] = None,
    custom_params: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    custom_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    dedupe_string_override: typing.Optional[builtins.str] = None,
    documentation_link: typing.Optional[builtins.str] = None,
    fill_alarm_range: typing.Optional[builtins.bool] = None,
    runbook_link: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e7a30d23d64a95bc8a70b4f63c1f5af29d8f769f0f78f364244045ef10bf036(
    disambiguator: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11a02d7d4ddfaedf045ac667fc31a518c626371c1c480b58786704f055e93095(
    custom_tag: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__54e7610248a417239be87b0d2e74510f3b0d17d10d14cbeead797637655bdc73(
    scope: _constructs_77d1e7e8.Construct,
    *,
    acm: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    api_gateway_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    app_sync: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    aurora_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    auto_scaling_group: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    billing: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    cloud_front: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    code_build: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    document_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    dynamo_db: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    ec2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    elastic_cache: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    glue: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_analytics: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_data_stream: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    kinesis_firehose: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    lambda_: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    open_search: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_cluster: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    rds_instance: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    redshift: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    s3: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    secrets_manager: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sns: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    sqs: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    step_functions: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    synthetics_canaries: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
    web_application_firewall_acl_v2: typing.Optional[typing.Union[MonitoringAspectType, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9c5c2bf61af593a718b0e529c0a4160380c5f6ff8d0cabc2055a5d614574570f(
    *,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    fallback_construct_name: typing.Optional[builtins.str] = None,
    named_construct: typing.Optional[_constructs_77d1e7e8.IConstruct] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3bbeb164e5ee70ac1270c16c03141b85dfe6eb0f76b8768ba20c858c3754e27(
    *,
    invert_statistics_of_task_count_enabled: typing.Optional[builtins.bool] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    network_load_balancer: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkLoadBalancer,
    network_target_group: _aws_cdk_aws_elasticloadbalancingv2_ceddda9d.INetworkTargetGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_healthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_healthy_task_percent_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HealthyTaskPercentThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_processed_bytes_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinProcessedBytesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_unhealthy_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UnhealthyTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96d32def4059f964413575b74ba39d3a2bf2cc63d93b851be5556e6a45ca2361(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3f8d22987fd34d2cd522c8bcd60018be8c0a2a0e34cf6890c727b637572246e(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    domain: typing.Union[_aws_cdk_aws_elasticsearch_ceddda9d.IDomain, _aws_cdk_aws_elasticsearch_ceddda9d.CfnDomain, _aws_cdk_aws_opensearchservice_ceddda9d.IDomain, _aws_cdk_aws_opensearchservice_ceddda9d.CfnDomain],
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cluster_automated_snapshot_failure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterAutomatedSnapshotFailureThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_index_writes_blocked_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterIndexWritesBlockedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_node_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterNodesThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cluster_status_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchClusterStatusCustomization, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_indexing_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_error_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyErrorThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_kms_key_inaccessible_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[OpenSearchKmsKeyInaccessibleThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_cpu_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_master_jvm_memory_pressure_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_search_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cff7fc9d3ad129c8a8dc3a541cdcba76d4ef482dcb8ea3d9a1711ae3f55d4931(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    ec2_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingEc2Service,
    add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39b9e2267d88e909794e18a10ba0f037ab69e18de50cdac527deb94a1e4e0221(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    fargate_service: _aws_cdk_aws_ecs_patterns_ceddda9d.QueueProcessingFargateService,
    add_dead_letter_queue_alarms: typing.Optional[typing.Union[BaseDlqAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    add_queue_alarms: typing.Optional[typing.Union[BaseSqsQueueAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
    add_service_alarms: typing.Optional[typing.Union[BaseFargateServiceAlarms, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e219c2939f4b9b6d12088714c4d6618b65addcf00c74c7474bd0320f659eab67(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cccf5c38b2eadfac7dfb25a9f9e763e0a6dbd136dd23e273f352f9df9f2cfc3(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9931a59fbfdc40f354ea561bd032703020d39066bc7c032a80b860e46659db92(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d258bbb1dfc8c915aa75a280eee01ef2e44aea4dc3b991acb4e66bf36719b46(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    instance: _aws_cdk_aws_rds_ceddda9d.IDatabaseInstance,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_free_storage_space_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinUsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__279f1230ddb7426695ad13c3a830b8eb66e046d1c02065a7d23833dfb6e37bda(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__318ed0bcb384be05f1813e20ee6b99241c45d6d23eaaeef5a6689c52e3ec83c8(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster_identifier: builtins.str,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_disk_space_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_long_query_duration_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86d9fb9242f927f6636bcb9208a2ee375457e90989fdeefcd6bf10acff3afd47(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a70b8e7362ba6c269e6eb3977b2ef9cc979176362788ee51c28c075080bbc36(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    storage_type: typing.Optional[StorageType] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae801214ce0813ff9ab3a1bd501bd7b46ceca77529881780d95cd7bc4624fd43(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bee12a48d6d7ef767b366302fa038929bfc298df919886dd7f0c40f2d81678a1(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_change_in_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ChangeInSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_secrets_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinSecretCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3df57dbef7f5517abf0ee4985240dab87c3280573198a138b608c6b17adca6e4(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    show_last_rotation_widget: typing.Optional[builtins.bool] = None,
    use_publisher: typing.Optional[IPublisherConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed2f768a4e58e42beabd7414a632d6f0050cd9a8c667ea13b88f504b48eb0e8a(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_days_since_last_change_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_days_since_last_rotation_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DaysSinceUpdateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    show_last_rotation_widget: typing.Optional[builtins.bool] = None,
    use_publisher: typing.Optional[IPublisherConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c535902c60dd4f7811a7db698d2c53c97c0dde23a6395960a08a7070e91f836(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    ec2_service: _aws_cdk_aws_ecs_ceddda9d.Ec2Service,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87470398c0479654a1b234bc837ba5ebcba77a0a9b31e1cd24f74e47199cbb33(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_ephermal_storage_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_memory_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_running_task_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[RunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    min_auto_scaling_task_count: typing.Optional[jsii.Number] = None,
    fargate_service: _aws_cdk_aws_ecs_ceddda9d.FargateService,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bb560a82205708572b3b74c8e3d2fba4dac6476aa342f5c5df39f3dbeb5f0b88(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f1112f4cb0e094faaedce0d97684d956b5bcfeefaa6b45f65ddf400c4c980f6(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    topic: _aws_cdk_aws_sns_ceddda9d.ITopic,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_max_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_message_notifications_failed_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[NotificationsFailedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_number_of_messages_published_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowMessagesPublishedThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a9078704844c2d99f4c20a13ce61629c7084ecba92e599c550938bdff60bcdd(
    *,
    add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6532398ecbbb3fa4eee48c0fc6d0857bdb4fadad7fb341a798b53258c0e97936(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0b15e4a0097bb5021a86236dfc10fb0f7d61edb4838c9bed5159404006dde085(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    add_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_max_time_to_drain_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxTimeToDrainThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_queue_min_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_dead_letter_queue_max_incoming_messages_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxIncomingMessagesCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_message_age_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageAgeThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_dead_letter_queue_max_size_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MaxMessageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    dead_letter_queue: _aws_cdk_aws_sqs_ceddda9d.IQueue,
    add_dead_letter_queue_to_summary_dashboard: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3219deac3e59d18dbb16d784c4e03451e55723c7693dc908e0d221c53e1c5d32(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    activity: _aws_cdk_aws_stepfunctions_ceddda9d.IActivity,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_activities_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_activities_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d2d7b1e2909623e368303672f6983450a565ae3ce6bef06f2b76416b15d30ae(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_functions_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_functions_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1119e9f6665bb8ec0bfc46e8b0842e051616bb11fc481f4e3f168c6c9de3e5d4(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4150cda6db7549a2d55053c64974a5dd7f488ca4db34a16b3e9fff4ceb8f7d68(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.IStateMachine,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_aborted_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_execution_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_started_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[MinRunningTaskCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_throttled_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_execution_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b8898e4d32066cc2acbe2d726b10ddfd080749e42d59379a40bca5b433519f44(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    service_integration_resource_arn: builtins.str,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_duration_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_duration_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[DurationThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_failed_service_integrations_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_timed_out_service_integrations_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0b367f8fefeb755686784efb64b65163152ae36d8a2334aeef0359ce4d5005da(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__469e6d4d399badb350095dbabd03e4abc53577bbb1717344ec4ba7a1692148a5(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    canary: _aws_cdk_aws_synthetics_ceddda9d.Canary,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_average_latency_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ebfbca8b6aa57717f044140e97941cb2cef3741a4102249def6b26af7c71ff4(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7075b042489cfae6d06cb7ff5692a6b80a22e550fd750f2740a85a2e74eb6ae2(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    acl: _aws_cdk_aws_wafv2_ceddda9d.CfnWebACL,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_blocked_requests_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_blocked_requests_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42dd4a21cb03789bd212240ccf2ec445cfad151a5fd165d1cf8663a2be045eca(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9c42d46bd924daca5f765f03a570200a4b4019939fabcdb69940282c19f7ff46(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    api: _aws_cdk_aws_apigateway_ceddda9d.IRestApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7df9fbdfb66638a7b7ea1397c791fafa4f5829038225f6419b693b04c92381e(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7689a26c6918f8b69df1dedcc71fe7c5c9be50b5c9025475908207e6c4a827fa(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d02bda64e67d06b43089dde217fd2da0d36374b94d0f777a89fed5911eed3ba0(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4_xx_error_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4_xx_error_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5_xx_fault_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    api: _aws_cdk_aws_appsync_ceddda9d.IGraphqlApi,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__574338a5659b6b1412329597010110743bd814bf74c2b3dfd3e18b133cb46ae0(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cdf794b2bdb96ec005eebaca725d331989d9e18a926022445c2c5cac7f5bff7(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    cluster: typing.Optional[typing.Union[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster, _aws_cdk_aws_rds_ceddda9d.ServerlessCluster]] = None,
    cluster_identifier: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add_cpu_usage_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_max_serverless_database_capacity_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[UsageCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_min_connection_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowConnectionCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e20eafd19e3c8290a8b7fca960f78f74170ec2c088028572ab8b4b1e2e060ecb(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f05524b746e80181a5a2702bde2a12630e481e0280632cb11b164894a2dd0c6(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    auto_scaling_group: _aws_cdk_aws_autoscaling_ceddda9d.IAutoScalingGroup,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc62460d72cc8f1ddc60328e8cb925681469024fd4244d40c80eb4546e6e3122(
    prefix: typing.Optional[builtins.str] = None,
    suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc3f94d08743043a08e42c28745bc42883e044246b024761b9bd90d15e7bbe1c(
    *,
    account: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    api: _aws_cdk_aws_apigatewayv2_ceddda9d.IHttpApi,
    api_method: typing.Optional[builtins.str] = None,
    api_resource: typing.Optional[builtins.str] = None,
    api_stage: typing.Optional[builtins.str] = None,
    fill_tps_with_zeroes: typing.Optional[builtins.bool] = None,
    rate_computation_method: typing.Optional[RateComputationMethod] = None,
    alarm_friendly_name: typing.Optional[builtins.str] = None,
    human_readable_name: typing.Optional[builtins.str] = None,
    local_alarm_name_prefix_override: typing.Optional[builtins.str] = None,
    add_to_alarm_dashboard: typing.Optional[builtins.bool] = None,
    add_to_detail_dashboard: typing.Optional[builtins.bool] = None,
    add_to_summary_dashboard: typing.Optional[builtins.bool] = None,
    use_created_alarms: typing.Optional[IAlarmConsumer] = None,
    add4xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add4xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_count_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorCountThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add5xx_rate_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[ErrorRateThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_high_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[HighTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_integration_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_average_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p100_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_p99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm50_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm70_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm90_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm95_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm9999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm999_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_latency_tm99_outlier_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LatencyThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    add_low_tps_alarm: typing.Optional[typing.Mapping[builtins.str, typing.Union[LowTpsThreshold, typing.Dict[builtins.str, typing.Any]]]] = None,
    latency_types_to_render: typing.Optional[typing.Sequence[LatencyType]] = None,
) -> None:
    """Type checking stubs"""
    pass
